nutshell 1.0.0

data/test/mocks/mock_open4.rb

@@ -0,0 +1,117 @@
+module MockOpen4
+
+  CMD_RETURN = {
+    Nutshell::RemoteShell::LOGIN_LOOP => [:out, "ready\n"]
+  }
+
+  attr_reader :cmd_log
+
+  def popen4(*args)
+    cmd = args.join(" ")
+    @cmd_log ||= []
+    @cmd_log << cmd
+
+
+    pid = "test_pid"
+    inn_w = StringIO.new
+    out_r, out_w = IO.pipe
+    err_r, err_w = IO.pipe
+
+    ios = {:inn => inn_w, :out => out_w, :err => err_w}
+    stream, string = output_for cmd
+
+    ios[stream].write string
+    out_w.write nil
+    err_w.write nil
+
+    out_w.close
+    err_w.close
+
+    if block_given?
+      yield
+      inn_w.close
+      out_r.close
+      err_r.close
+    end
+
+    return pid, inn_w, out_r, err_r
+  end
+
+  def output_for(cmd)
+    @mock_output ||= {}
+    if @mock_output
+      output = @mock_output[cmd]
+      output ||= @mock_output[nil].shift if Array === @mock_output[nil]
+      @mock_output.delete(cmd)
+      if output
+        Process.set_exitcode output.delete(output.last)
+        return output
+      end
+    end
+
+    CMD_RETURN.each do |cmd_key, return_val|
+      return return_val if cmd.include? cmd_key
+    end
+    return :out, "some_value"
+  end
+
+  def set_mock_response code, stream_vals={}, options={}
+    @mock_output ||= {}
+    @mock_output[nil] ||= []
+    new_stream_vals = {}
+
+    stream_vals.each do |key, val|
+      if Symbol === key
+        @mock_output[nil] << [key, val, code]
+        next
+      end
+
+      if Nutshell::RemoteShell === self
+        key = build_remote_cmd(key, options).join(" ")
+      end
+
+      new_stream_vals[key] = (val.dup << code)
+    end
+    @mock_output.merge! new_stream_vals
+  end
+
+end
+
+
+class StatusStruct < Struct.new("Status", :exitstatus)
+  def success?
+    self.exitstatus == 0
+  end
+end
+
+
+Process.class_eval do
+  class << self
+
+    def set_exitcode(code)
+      @exit_code = code
+    end
+
+    alias old_waitpid2 waitpid2
+    undef waitpid2
+
+    def waitpid2(*args)
+      pid = args[0]
+      if pid == "test_pid"
+        exitcode = @exit_code ||= 0
+        @exit_code = 0
+        return [StatusStruct.new(exitcode)]
+      else
+        return old_waitpid2(*args)
+      end
+    end
+
+    alias old_kill kill
+    undef kill
+
+    def kill(type, pid)
+      return true if type == 0 && pid == "test_pid"
+      old_kill(type, pid)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,108 @@
+require 'nutshell'
+require 'test/unit'
+
+require 'test/mocks/mock_object'
+require 'test/mocks/mock_open4'
+
+
+def mock_remote_shell host=nil
+  host ||= "user@some_server.com"
+  remote_shell = Nutshell::RemoteShell.new host
+
+  remote_shell.extend MockOpen4
+  remote_shell.extend MockObject
+
+  use_remote_shell remote_shell
+
+  remote_shell.connect
+  remote_shell
+end
+
+
+def mock_remote_shell host=nil
+  host ||= "user@some_server.com"
+  remote_shell = Nutshell::RemoteShell.new host
+
+  remote_shell.extend MockOpen4
+  remote_shell.extend MockObject
+
+  use_remote_shell remote_shell
+
+  remote_shell.connect
+  remote_shell
+end
+
+
+def assert_not_called *args
+  assert !@remote_shell.method_called?(:call, :args => [*args]),
+    "Command called by #{@remote_shell.host} but should't have:\n #{args[0]}"
+end
+
+
+def assert_server_call *args
+  assert @remote_shell.method_called?(:call, :args => [*args]),
+    "Command was not called by #{@remote_shell.host}:\n #{args[0]}"
+end
+
+
+def assert_bash_script name, cmds, check_value
+  cmds = cmds.map{|cmd| "(#{cmd})" }
+  cmds << "echo true"
+
+  bash = <<-STR
+#!/bin/bash
+if [ "$1" == "--no-env" ]; then
+#{cmds.flatten.join(" && ")}
+else
+#{@app.root_path}/env #{@app.root_path}/#{name} --no-env
+fi
+  STR
+
+  assert_equal bash, check_value
+end
+
+
+def assert_ssh_call expected, ds=@remote_shell, options={}
+  expected = ds.build_remote_cmd(expected, options).join(" ")
+
+  error_msg = "No such command in remote_shell log [#{ds.host}]\n#{expected}"
+  error_msg << "\n\n#{ds.cmd_log.select{|c| c =~ /^ssh/}.join("\n\n")}"
+
+  assert ds.cmd_log.include?(expected), error_msg
+end
+
+
+def assert_rsync from, to, ds=@remote_shell, sudo=false
+  received = ds.cmd_log.last
+
+  rsync_path = if sudo
+    path = ds.sudo_cmd('rsync', sudo).join(' ')
+    "--rsync-path='#{ path }' "
+  end
+
+  rsync_cmd = "rsync -azP #{rsync_path}-e \"ssh #{ds.ssh_flags.join(' ')}\""
+
+  error_msg = "No such command in remote_shell log [#{ds.host}]\n#{rsync_cmd}"
+  error_msg << "#{from.inspect} #{to.inspect}"
+  error_msg << "\n\n#{ds.cmd_log.select{|c| c =~ /^rsync/}.join("\n\n")}"
+
+  if Regexp === from
+    found = ds.cmd_log.select do |cmd|
+
+      cmd_from = cmd.split(" ")[-2]
+      cmd_to   = cmd.split(" ").last
+
+      cmd_from =~ from && cmd_to == to && cmd.index(rsync_cmd) == 0
+    end
+
+    assert !found.empty?, error_msg
+  else
+    expected = "#{rsync_cmd} #{from} #{to}"
+    assert ds.cmd_log.include?(expected), error_msg
+  end
+end
+
+
+def use_remote_shell remote_shell
+  @remote_shell = remote_shell
+end

data/test/test_remote_shell.rb

@@ -0,0 +1,102 @@
+require 'test/test_helper'
+
+class TestRemoteShell < Test::Unit::TestCase
+
+  def setup
+    Nutshell::RemoteShell.class_eval{ include MockOpen4 }
+
+    @host = "user@some_server.com"
+    @remote_shell = mock_remote_shell @host
+  end
+
+  def teardown
+    @remote_shell.disconnect
+  end
+
+  def test_connect
+    login_cmd = Nutshell::RemoteShell::LOGIN_LOOP
+    login_cmd = @remote_shell.send :quote_cmd, login_cmd
+    login_cmd = @remote_shell.send :ssh_cmd, login_cmd, :sudo => false
+
+    assert @remote_shell.method_called?(:popen4, :args => [login_cmd.join(" ")])
+    assert @remote_shell.connected?
+  end
+
+  def test_disconnect
+    @remote_shell.disconnect
+    assert !@remote_shell.connected?
+  end
+
+  def test_call
+    @remote_shell.call "echo 'line1'; echo 'line2'"
+    assert_ssh_call "echo 'line1'; echo 'line2'"
+
+    @remote_shell.sudo = "sudouser"
+    @remote_shell.call "sudocall"
+    assert_ssh_call "sudocall", @remote_shell, :sudo => "sudouser"
+  end
+
+  def test_call_with_stderr
+    @remote_shell.set_mock_response 1, :err => 'this is an error'
+    cmd = "echo 'this is an error'"
+    @remote_shell.call cmd
+    raise "Didn't raise CmdError on stderr"
+  rescue Nutshell::CmdError => e
+    ssh_cmd = @remote_shell.build_remote_cmd(cmd).join(" ")
+    assert_equal "Execution failed with status 1: #{ssh_cmd}", e.message
+  end
+
+  def test_upload
+    @remote_shell.upload "test/fixtures/nutshell_test", "nutshell_test"
+    assert_rsync "test/fixtures/nutshell_test",
+      "#{@remote_shell.host}:nutshell_test"
+
+    @remote_shell.sudo = "blah"
+    @remote_shell.upload "test/fixtures/nutshell_test", "nutshell_test"
+    assert_rsync "test/fixtures/nutshell_test",
+      "#{@remote_shell.host}:nutshell_test", @remote_shell, "blah"
+  end
+
+  def test_download
+    @remote_shell.download "nutshell_test", "."
+    assert_rsync "#{@remote_shell.host}:nutshell_test", "."
+
+    @remote_shell.download "nutshell_test", ".", :sudo => "sudouser"
+    assert_rsync "#{@remote_shell.host}:nutshell_test", ".",
+      @remote_shell, "sudouser"
+  end
+
+  def test_make_file
+    @remote_shell.make_file("some_dir/nutshell_test_file", "test data")
+    tmp_file = "#{Nutshell::TMP_DIR}/nutshell_test_file"
+    tmp_file = Regexp.escape tmp_file
+    assert_rsync(/^#{tmp_file}_[0-9]+/,
+      "#{@remote_shell.host}:some_dir/nutshell_test_file")
+  end
+
+  def test_os_name
+    @remote_shell.os_name
+    assert_ssh_call "uname -s"
+  end
+
+  def test_equality
+    ds_equal = Nutshell::RemoteShell.new @host
+    ds_diff1 = Nutshell::RemoteShell.new @host, :user => "blarg"
+    ds_diff2 = Nutshell::RemoteShell.new "some_other_host"
+
+    assert_equal ds_equal, @remote_shell
+    assert_equal ds_diff1, @remote_shell
+    assert ds_diff2 != @remote_shell
+  end
+
+  def test_file?
+    @remote_shell.file? "some/file/path"
+    assert_ssh_call "test -f some/file/path"
+  end
+
+  def test_symlink
+    @remote_shell.symlink "target_file", "sym_name"
+    assert_ssh_call "ln -sfT target_file sym_name"
+  end
+end
+

data/test/test_shell.rb

@@ -0,0 +1,98 @@
+require 'test/test_helper'
+
+class TestShell < Test::Unit::TestCase
+
+  def setup
+    @output = StringIO.new
+    @output.extend MockObject
+
+    @shell = Nutshell::Shell.new @output
+    @shell.extend MockOpen4
+
+    @shell.input.extend MockObject
+    @shell.input.mock :ask, :return => "someinput"
+  end
+
+
+  def test_initialize
+    assert_equal @output, @shell.output
+    assert_equal HighLine, @shell.input.class
+    assert_equal `whoami`.chomp, @shell.user
+    assert_equal `hostname`.chomp, @shell.host
+  end
+
+
+  def test_ask
+    @shell.ask "input something!"
+    assert 1, @shell.input.method_call_count(:ask)
+  end
+
+
+  def test_close
+    @shell.close
+    assert 1, @shell.output.method_call_count(:close)
+  end
+
+
+  def test_write
+    @shell.write "blah"
+    assert @output.method_called?(:write, :args => "blah")
+  end
+
+
+  def test_prompt_for_password
+    @shell.prompt_for_password
+
+    args = "#{@shell.user}@#{@shell.host} Password:"
+    assert @shell.input.method_called?(:ask, :args => args)
+    assert_equal "someinput", @shell.password
+  end
+
+
+  def test_execute
+    @shell.set_mock_response 0, "say hi"   => [:out, "hi\n"]
+
+    response = @shell.execute("say hi") do |stream, data|
+      assert_equal :out, stream
+      assert_equal "hi\n", data
+    end
+    assert_equal "hi", response
+  end
+
+
+  def test_execute_errorstatus
+    @shell.set_mock_response 1, "error me" => [:err, "ERROR'D!"]
+
+    begin
+      @shell.execute("error me") do |stream, data|
+        assert_equal :err, stream
+        assert_equal "ERROR'D!", data
+      end
+      raise "Didn't call CmdError when it should have"
+    rescue Nutshell::CmdError => e
+      msg = "Execution failed with status 1: error me"
+      assert_equal msg, e.message
+    end
+  end
+
+
+  def test_execute_stderronly
+    @shell.set_mock_response 0, "stderr"   => [:err, "fake error"]
+
+    response = @shell.execute("stderr") do |stream, data|
+      assert_equal :err, stream
+      assert_equal "fake error", data
+    end
+    assert_equal "", response
+  end
+
+
+  def test_execute_password_prompt
+    @shell.set_mock_response 0, "do that thing" => [:err, "Password:"]
+    @shell.input.mock :ask, :return => "new_password"
+
+    @shell.execute("do that thing")
+    assert_equal "new_password", @shell.password
+  end
+end
+

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification 
+name: nutshell
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jeremie Castagna
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-28 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: open4
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 3
+        version: 2.3.3
+  type: :development
+  version_requirements: *id003
+description: A light weight ssh client that wraps the ssh and rsync commands.
+email: 
+- yaksnrainbows@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/nutshell.rb
+- lib/nutshell/remote_shell.rb
+- lib/nutshell/shell.rb
+- test/mocks/mock_object.rb
+- test/mocks/mock_open4.rb
+- test/test_helper.rb
+- test/test_remote_shell.rb
+- test/test_shell.rb
+has_rdoc: true
+homepage: http://github.com/yaksnrainbows/nutshell
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: nutshell
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A light weight ssh client that wraps the ssh and rsync commands.
+test_files: 
+- test/test_helper.rb
+- test/test_remote_shell.rb
+- test/test_shell.rb