terrapin 0.6.0.alpha

data/spec/terrapin/command_line/runners/backticks_runner_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Terrapin::CommandLine::BackticksRunner do
+  if Terrapin::CommandLine::BackticksRunner.supported?
+    it_behaves_like 'a command that does not block'
+
+    it 'runs the command given and captures the output in an Output' do
+      output = subject.call("echo hello")
+      expect(output).to have_output "hello\n"
+    end
+
+    it 'modifies the environment and runs the command given' do
+      output = subject.call("echo $yes", {"yes" => "no"})
+      expect(output).to have_output "no\n"
+    end
+
+    it 'sets the exitstatus when a command completes' do
+      subject.call("ruby -e 'exit 0'")
+      $?.exitstatus.should == 0
+      subject.call("ruby -e 'exit 5'")
+      $?.exitstatus.should == 5
+    end
+  end
+end

data/spec/terrapin/command_line/runners/fake_runner_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Terrapin::CommandLine::FakeRunner do
+  it 'records commands' do
+    subject.call("some command", :environment)
+    subject.call("other command", :other_environment)
+    subject.commands.should eq [["some command", :environment], ["other command", :other_environment]]
+  end
+
+  it 'can tell if a command was run' do
+    subject.call("some command", :environment)
+    subject.call("other command", :other_environment)
+    subject.ran?("some command").should eq true
+    subject.ran?("no command").should eq false
+  end
+
+  it 'can tell if a command was run even if shell options were set' do
+    subject.call("something 2>/dev/null", :environment)
+    subject.ran?("something").should eq true
+  end
+
+end

data/spec/terrapin/command_line/runners/popen_runner_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Terrapin::CommandLine::PopenRunner do
+  if Terrapin::CommandLine::PopenRunner.supported?
+    it_behaves_like 'a command that does not block'
+
+    it 'runs the command given and captures the output in an Output' do
+      output = subject.call("echo hello")
+      expect(output).to have_output "hello\n"
+    end
+
+    it 'modifies the environment and runs the command given' do
+      output = subject.call("echo $yes", {"yes" => "no"})
+      expect(output).to have_output "no\n"
+    end
+
+    it 'sets the exitstatus when a command completes' do
+      subject.call("ruby -e 'exit 0'")
+      $?.exitstatus.should == 0
+      subject.call("ruby -e 'exit 5'")
+      $?.exitstatus.should == 5
+    end
+  end
+end

data/spec/terrapin/command_line/runners/posix_runner_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Terrapin::CommandLine::PosixRunner do
+  if Terrapin::CommandLine::PosixRunner.supported?
+    it_behaves_like 'a command that does not block'
+
+    it 'runs the command given and captures the output' do
+      output = subject.call("echo hello")
+      expect(output).to have_output "hello\n"
+    end
+
+    it 'runs the command given and captures the error output' do
+      output = subject.call("echo hello 1>&2")
+      expect(output).to have_error_output "hello\n"
+    end
+
+    it 'modifies the environment and runs the command given' do
+      output = subject.call("echo $yes", {"yes" => "no"})
+      expect(output).to have_output "no\n"
+    end
+
+    it 'sets the exitstatus when a command completes' do
+      subject.call("ruby -e 'exit 0'")
+      $?.exitstatus.should == 0
+      subject.call("ruby -e 'exit 5'")
+      $?.exitstatus.should == 5
+    end
+
+    it "runs the command it's given and allows access to stderr afterwards" do
+      cmd = Terrapin::CommandLine.new(
+        "ruby",
+        "-e '$stdout.puts %{hello}; $stderr.puts %{goodbye}'",
+        :swallow_stderr => false
+      )
+      cmd.run
+      expect(cmd.command_output).to eq "hello\n"
+      expect(cmd.command_error_output).to eq "goodbye\n"
+    end
+  end
+end

data/spec/terrapin/command_line/runners/process_runner_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Terrapin::CommandLine::ProcessRunner do
+  if Terrapin::CommandLine::ProcessRunner.supported?
+    it_behaves_like "a command that does not block"
+
+    it 'runs the command given and captures the output' do
+      output = subject.call("echo hello")
+      expect(output).to have_output "hello\n"
+    end
+
+    it 'runs the command given and captures the error output' do
+      output = subject.call("echo hello 1>&2")
+      expect(output).to have_error_output "hello\n"
+    end
+
+    it 'modifies the environment and runs the command given' do
+      output = subject.call("echo $yes", {"yes" => "no"})
+      expect(output).to have_output "no\n"
+    end
+
+    it 'sets the exitstatus when a command completes' do
+      subject.call("ruby -e 'exit 0'")
+      $?.exitstatus.should == 0
+      subject.call("ruby -e 'exit 5'")
+      $?.exitstatus.should == 5
+    end
+
+    it "runs the command it's given and allows access to stderr afterwards" do
+      cmd = Terrapin::CommandLine.new(
+        "ruby",
+        "-e '$stdout.puts %{hello}; $stderr.puts %{goodbye}'",
+        :swallow_stderr => false
+      )
+      cmd.run
+      expect(cmd.command_output).to eq "hello\n"
+      expect(cmd.command_error_output).to eq "goodbye\n"
+    end
+  end
+end

data/spec/terrapin/command_line_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe Terrapin::CommandLine do
+  before do
+    Terrapin::CommandLine.path = nil
+    on_unix! # Assume we're on unix unless otherwise specified.
+  end
+
+  it "takes a command and parameters and produces a Bash command line" do
+    cmd = Terrapin::CommandLine.new("convert", "a.jpg b.png", :swallow_stderr => false)
+    cmd.command.should == "convert a.jpg b.png"
+  end
+
+  it "specifies the $PATH where the command can be found on unix" do
+    Terrapin::CommandLine.path = ["/path/to/command/dir", "/"]
+    cmd = Terrapin::CommandLine.new("ls")
+    cmd.command.should == "PATH=/path/to/command/dir:/:$PATH; ls"
+  end
+
+  it "specifies the %PATH% where the command can be found on windows" do
+    on_windows!
+    Terrapin::CommandLine.path = ['C:\system32', 'D:\\']
+    cmd = Terrapin::CommandLine.new("dir")
+    cmd.command.should == 'SET PATH=C:\system32;D:\;%PATH% & dir'
+  end
+
+  it "specifies more than one path where the command can be found" do
+    Terrapin::CommandLine.path = ["/path/to/command/dir", "/some/other/path"]
+    cmd = Terrapin::CommandLine.new("ruby", "-e 'puts ENV[%{PATH}]'")
+    output = cmd.run
+    output.should match(%r{/path/to/command/dir})
+    output.should match(%r{/some/other/path})
+  end
+
+  it "temporarily changes specified environment variables" do
+    Terrapin::CommandLine.environment['TEST'] = 'Hello, world!'
+    cmd = Terrapin::CommandLine.new("ruby", "-e 'puts ENV[%{TEST}]'")
+    output = cmd.run
+    output.should match(%r{Hello, world!})
+  end
+
+  it 'changes environment variables for the command line' do
+    Terrapin::CommandLine.environment['TEST'] = 'Hello, world!'
+    cmd = Terrapin::CommandLine.new("ruby",
+                                   "-e 'puts ENV[%{TEST}]'",
+                                   :environment => {'TEST' => 'Hej hej'})
+    output = cmd.run
+    output.should match(%r{Hej hej})
+  end
+
+  it 'passes the existing environment variables through to the runner' do
+    command = Terrapin::CommandLine.new('echo', '$HOME')
+    output = command.run
+    output.chomp.should_not == ''
+  end
+
+  it "can interpolate quoted variables into the command line's parameters" do
+    cmd = Terrapin::CommandLine.new("convert",
+                                   ":one :{two}",
+                                   :swallow_stderr => false)
+
+    command_string = cmd.command(:one => "a.jpg", :two => "b.png")
+    command_string.should == "convert 'a.jpg' 'b.png'"
+  end
+
+  it 'does not over-interpolate in a command line' do
+    cmd = Terrapin::CommandLine.new("convert",
+                                   ":hell :{two} :hello",
+                                   :swallow_stderr => false)
+
+    command_string = cmd.command(:hell => "a.jpg", :two => "b.png", :hello => "c.tiff")
+    command_string.should == "convert 'a.jpg' 'b.png' 'c.tiff'"
+  end
+
+  it "interpolates when running a command" do
+    command = Terrapin::CommandLine.new("echo", ":hello_world")
+    command.run(:hello_world => "Hello, world").should match(/Hello, world/)
+  end
+
+  it "interpolates any Array arguments when running a command" do
+    command = Terrapin::CommandLine.new("echo", "Hello :worlds and :dwarfs")
+    command.command(:worlds => %w[mercury venus earth], :dwarfs => "pluto").should == "echo Hello 'mercury' 'venus' 'earth' and 'pluto'"
+  end
+
+  it "quotes command line options differently if we're on windows" do
+    on_windows!
+    cmd = Terrapin::CommandLine.new("convert",
+                                   ":one :{two}",
+                                   :swallow_stderr => false)
+    command_string = cmd.command(:one => "a.jpg", :two => "b.png")
+    command_string.should == 'convert "a.jpg" "b.png"'
+  end
+
+  it "can quote and interpolate dangerous variables" do
+    cmd = Terrapin::CommandLine.new("convert",
+                                   ":one :two",
+                                   :swallow_stderr => false)
+    command_string = cmd.command(:one => "`rm -rf`.jpg", :two => "ha'ha.png'")
+    command_string.should == "convert '`rm -rf`.jpg' 'ha'\\''ha.png'\\'''"
+  end
+
+  it 'cannot recursively introduce a place where user-supplied commands can run' do
+    cmd = Terrapin::CommandLine.new('convert', ':foo :bar')
+    cmd.command(:foo => ':bar', :bar => '`rm -rf`').should == 'convert \':bar\' \'`rm -rf`\''
+  end
+
+  it "can quote and interpolate dangerous variables even on windows" do
+    on_windows!
+    cmd = Terrapin::CommandLine.new("convert",
+                                   ":one :two",
+                                   :swallow_stderr => false)
+    command_string = cmd.command(:one => "`rm -rf`.jpg", :two => "ha'ha.png")
+    command_string.should == %{convert "`rm -rf`.jpg" "ha'ha.png"}
+  end
+
+  it "quotes blank values into the command line's parameters" do
+    cmd = Terrapin::CommandLine.new("curl",
+                                   "-X POST -d :data :url",
+                                   :swallow_stderr => false)
+    command_string = cmd.command(:data => "", :url => "http://localhost:9000")
+    command_string.should == "curl -X POST -d '' 'http://localhost:9000'"
+  end
+
+  it "allows colons in parameters" do
+    cmd = Terrapin::CommandLine.new("convert", "'a.jpg' xc:black 'b.jpg'", :swallow_stderr => false)
+    cmd.command.should == "convert 'a.jpg' xc:black 'b.jpg'"
+  end
+
+  it 'handles symbols in user supplied values' do
+    cmd = Terrapin::CommandLine.new("echo", ":foo")
+    command_string = cmd.command(:foo => :bar)
+    command_string.should == "echo 'bar'"
+  end
+
+  it "can redirect stderr to the bit bucket if requested" do
+    cmd = Terrapin::CommandLine.new("convert",
+                                   "a.jpg b.png",
+                                   :swallow_stderr => true)
+
+    cmd.command.should == "convert a.jpg b.png 2>/dev/null"
+  end
+
+  it "can redirect stderr to the bit bucket on windows" do
+    on_windows!
+    cmd = Terrapin::CommandLine.new("convert",
+                                   "a.jpg b.png",
+                                   :swallow_stderr => true)
+
+    cmd.command.should == "convert a.jpg b.png 2>NUL"
+  end
+
+  it "runs the command it's given and returns the output" do
+    cmd = Terrapin::CommandLine.new("echo", "hello", :swallow_stderr => false)
+    expect(cmd.run).to eq "hello\n"
+  end
+
+  it "runs the command it's given and allows access to stdout afterwards" do
+    cmd = Terrapin::CommandLine.new("echo", "hello", :swallow_stderr => false)
+    cmd.run
+    expect(cmd.command_output).to eq "hello\n"
+  end
+
+  it "colorizes the output to a tty" do
+    logger = FakeLogger.new(:tty => true)
+    Terrapin::CommandLine.new("echo", "'Logging!' :foo", :logger => logger).run(:foo => "bar")
+    logger.entries.should include("\e[32mCommand\e[0m :: echo 'Logging!' 'bar'")
+  end
+
+  it 'can still take something that does not respond to tty as a logger' do
+    output_buffer = StringIO.new
+    logger = best_logger.new(output_buffer)
+    logger.should_not respond_to(:tty?)
+    Terrapin::CommandLine.new("echo", "'Logging!' :foo", :logger => logger).run(:foo => "bar")
+    output_buffer.rewind
+    output_buffer.read.should == "Command :: echo 'Logging!' 'bar'\n"
+  end
+
+  it "logs the command to a supplied logger" do
+    logger = FakeLogger.new
+    Terrapin::CommandLine.new("echo", "'Logging!' :foo", :logger => logger).run(:foo => "bar")
+    logger.entries.should include("Command :: echo 'Logging!' 'bar'")
+  end
+
+  it "logs the command to a default logger" do
+    Terrapin::CommandLine.logger = FakeLogger.new
+    Terrapin::CommandLine.new("echo", "'Logging!'").run
+    Terrapin::CommandLine.logger.entries.should include("Command :: echo 'Logging!'")
+  end
+
+  it "is fine if no logger is supplied" do
+    Terrapin::CommandLine.logger = nil
+    cmd = Terrapin::CommandLine.new("echo", "'Logging!'", :logger => nil)
+    lambda { cmd.run }.should_not raise_error
+  end
+end

data/spec/terrapin/errors_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe "When an error happens" do
+  it "raises a CommandLineError if the result code command isn't expected" do
+    cmd = Terrapin::CommandLine.new("echo", "hello")
+    cmd.stubs(:execute)
+    with_exitstatus_returning(1) do
+      lambda { cmd.run }.should raise_error(Terrapin::CommandLineError)
+    end
+  end
+
+  it "does not raise if the result code is expected, even if nonzero" do
+    cmd = Terrapin::CommandLine.new("echo", "hello", expected_outcodes: [0, 1])
+    cmd.stubs(:execute)
+    with_exitstatus_returning(1) do
+      lambda { cmd.run }.should_not raise_error
+    end
+  end
+
+  it "adds command output to exception message if the result code is nonzero" do
+    cmd = Terrapin::CommandLine.new("echo", "hello")
+    error_output = "Error 315"
+    cmd.
+      stubs(:execute).
+      returns(Terrapin::CommandLine::Output.new("", error_output))
+    with_exitstatus_returning(1) do
+      begin
+        cmd.run
+      rescue Terrapin::ExitStatusError => e
+        e.message.should =~ /STDERR:\s+#{error_output}/
+      end
+    end
+  end
+
+  it 'passes the error message to the exception when command is not found' do
+    cmd = Terrapin::CommandLine.new('test', '')
+    cmd.stubs(:execute).raises(Errno::ENOENT.new("not found"))
+    begin
+      cmd.run
+    rescue Terrapin::CommandNotFoundError => e
+      expect(e.message).to eq 'No such file or directory - not found'
+    end
+  end
+
+  it "should keep result code in #exitstatus" do
+    cmd = Terrapin::CommandLine.new("convert")
+    cmd.stubs(:execute).with("convert").returns(:correct_value)
+    with_exitstatus_returning(1) do
+      cmd.run rescue nil
+    end
+    cmd.exit_status.should == 1
+  end
+
+  it "does not blow up if running the command errored before execution" do
+    assuming_no_processes_have_been_run
+    command = Terrapin::CommandLine.new("echo", ":hello_world")
+    command.stubs(:command).raises("An Error")
+
+    lambda{ command.run }.should raise_error("An Error")
+    command.exit_status.should eq 0
+  end
+end

data/spec/terrapin/os_detector_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Terrapin::OSDetector do
+  it "detects that the system is unix" do
+    on_unix!
+    Terrapin::OS.should be_unix
+  end
+
+  it "detects that the system is windows" do
+    on_windows!
+    Terrapin::OS.should be_windows
+  end
+
+  it "detects that the system is windows (mingw)" do
+    on_mingw!
+    Terrapin::OS.should be_windows
+  end
+
+  it "detects that the current Ruby is on Java" do
+    on_java!
+    Terrapin::OS.should be_java
+  end
+end

data/spec/terrapin/runners_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe "When picking a Runner" do
+  it "uses the BackticksRunner by default" do
+    Terrapin::CommandLine::ProcessRunner.stubs(:supported?).returns(false)
+    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(false)
+
+    cmd = Terrapin::CommandLine.new("echo", "hello")
+
+    cmd.runner.class.should == Terrapin::CommandLine::BackticksRunner
+  end
+
+  it "uses the ProcessRunner on 1.9 and it's available" do
+    Terrapin::CommandLine::ProcessRunner.stubs(:supported?).returns(true)
+    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(false)
+
+    cmd = Terrapin::CommandLine.new("echo", "hello")
+    cmd.runner.class.should == Terrapin::CommandLine::ProcessRunner
+  end
+
+  it "uses the PosixRunner if the PosixRunner is available" do
+    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(true)
+
+    cmd = Terrapin::CommandLine.new("echo", "hello")
+    cmd.runner.class.should == Terrapin::CommandLine::PosixRunner
+  end
+
+  it "uses the BackticksRunner if the PosixRunner is available, but we told it to use Backticks all the time" do
+    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(true)
+    Terrapin::CommandLine.runner = Terrapin::CommandLine::BackticksRunner.new
+
+    cmd = Terrapin::CommandLine.new("echo", "hello")
+    cmd.runner.class.should == Terrapin::CommandLine::BackticksRunner
+  end
+
+  it "uses the BackticksRunner if the PosixRunner is available, but we told it to use Backticks" do
+    Terrapin::CommandLine::PosixRunner.stubs(:supported?).returns(true)
+
+    cmd = Terrapin::CommandLine.new("echo", "hello", :runner => Terrapin::CommandLine::BackticksRunner.new)
+    cmd.runner.class.should == Terrapin::CommandLine::BackticksRunner
+  end
+
+  it "can go into 'Fake' mode" do
+    Terrapin::CommandLine.fake!
+
+    cmd = Terrapin::CommandLine.new("echo", "hello")
+    cmd.runner.class.should eq Terrapin::CommandLine::FakeRunner
+  end
+
+  it "can turn off Fake mode" do
+    Terrapin::CommandLine.fake!
+    Terrapin::CommandLine.unfake!
+
+    cmd = Terrapin::CommandLine.new("echo", "hello")
+    cmd.runner.class.should_not eq Terrapin::CommandLine::FakeRunner
+  end
+
+  it "can use a FakeRunner even if not in Fake mode" do
+    Terrapin::CommandLine.unfake!
+
+    cmd = Terrapin::CommandLine.new("echo", "hello", :runner => Terrapin::CommandLine::FakeRunner.new)
+    cmd.runner.class.should eq Terrapin::CommandLine::FakeRunner
+  end
+end
+
+describe 'When running an executable in the supplemental path' do
+  before do
+    path = Pathname.new(File.dirname(__FILE__)) + '..' + 'support'
+    File.open(path + 'ls', 'w'){|f| f.puts "#!/bin/sh\necho overridden-ls\n" }
+    FileUtils.chmod(0755, path + 'ls')
+    Terrapin::CommandLine.path = path
+  end
+
+  after do
+    FileUtils.rm_f("#{Terrapin::CommandLine.path}/ls")
+  end
+
+  [
+    Terrapin::CommandLine::BackticksRunner,
+    Terrapin::CommandLine::PopenRunner,
+    Terrapin::CommandLine::PosixRunner,
+    Terrapin::CommandLine::ProcessRunner
+  ].each do |runner_class|
+    if runner_class.supported?
+      describe runner_class do
+        describe '#run' do
+          it 'finds the correct executable' do
+            Terrapin::CommandLine.runner = runner_class.new
+            command = Terrapin::CommandLine.new('ls')
+            result = command.run
+            expect(result.strip).to eq('overridden-ls')
+          end
+        end
+      end
+    end
+  end
+end