capistrano 2.0.0 → 2.15.2

data/test/command_test.rb

@@ -1,129 +1,127 @@
-require "#{File.dirname(__FILE__)}/utils"
+require "utils"
 require 'capistrano/command'
+require 'capistrano/configuration'
 
 class CommandTest < Test::Unit::TestCase
   def test_command_should_open_channels_on_all_sessions
-    s1 = mock(:open_channel => nil)
-    s2 = mock(:open_channel => nil)
-    s3 = mock(:open_channel => nil)
-    assert_equal "ls", Capistrano::Command.new("ls", [s1, s2, s3]).command
+    s1, s2, s3 = mock_session, mock_session, mock_session
+    assert_equal "ls", Capistrano::Command.new("ls", [s1, s2, s3]).tree.fallback.command
   end
 
   def test_command_with_newlines_should_be_properly_escaped
-    cmd = Capistrano::Command.new("ls\necho", [mock(:open_channel => nil)])
-    assert_equal "ls\\\necho", cmd.command
+    cmd = Capistrano::Command.new("ls\necho", [mock_session])
+    assert_equal "ls\\\necho", cmd.tree.fallback.command
   end
 
   def test_command_with_windows_newlines_should_be_properly_escaped
-    cmd = Capistrano::Command.new("ls\r\necho", [mock(:open_channel => nil)])
-    assert_equal "ls\\\necho", cmd.command
+    cmd = Capistrano::Command.new("ls\r\necho", [mock_session])
+    assert_equal "ls\\\necho", cmd.tree.fallback.command
+  end
+
+  def test_command_with_pty_should_request_pty_and_register_success_callback
+    session = setup_for_extracting_channel_action(:request_pty, true) do |ch|
+      ch.expects(:exec).with(%(sh -c 'ls'))
+    end
+    Capistrano::Command.new("ls", [session], :pty => true)
   end
 
   def test_command_with_env_key_should_have_environment_constructed_and_prepended
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(env FOO=bar sh -c "ls"))
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:request_pty).never
+      ch.expects(:exec).with(%(env FOO=bar sh -c 'ls'))
     end
     Capistrano::Command.new("ls", [session], :env => { "FOO" => "bar" })
   end
 
   def test_env_with_symbolic_key_should_be_accepted_as_a_string
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(env FOO=bar sh -c "ls"))
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(env FOO=bar sh -c 'ls'))
     end
     Capistrano::Command.new("ls", [session], :env => { :FOO => "bar" })
   end
 
   def test_env_as_string_should_be_substituted_in_directly
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(env HOWDY=there sh -c "ls"))
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(env HOWDY=there sh -c 'ls'))
     end
     Capistrano::Command.new("ls", [session], :env => "HOWDY=there")
   end
 
   def test_env_with_symbolic_value_should_be_accepted_as_string
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(env FOO=bar sh -c "ls"))
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(env FOO=bar sh -c 'ls'))
     end
     Capistrano::Command.new("ls", [session], :env => { "FOO" => :bar })
   end
 
   def test_env_value_should_be_escaped
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(env FOO=(\\ \\\"bar\\\"\\ ) sh -c "ls"))
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(env FOO=(\\ \\\"bar\\\"\\ ) sh -c 'ls'))
     end
     Capistrano::Command.new("ls", [session], :env => { "FOO" => '( "bar" )' })
   end
 
   def test_env_with_multiple_keys_should_chain_the_entries_together
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with do |command|
         command =~ /^env / &&
         command =~ /\ba=b\b/ &&
         command =~ /\bc=d\b/ &&
         command =~ /\be=f\b/ &&
-        command =~ / sh -c "ls"$/
+        command =~ / sh -c 'ls'$/
       end
     end
     Capistrano::Command.new("ls", [session], :env => { :a => :b, :c => :d, :e => :f })
   end
 
   def test_open_channel_should_set_host_key_on_channel
-    session = mock(:xserver => server("capistrano"))
-    channel = stub_everything
-
-    session.expects(:open_channel).yields(channel)
-    channel.expects(:[]=).with(:host, "capistrano")
-
+    channel = nil
+    session = setup_for_extracting_channel_action { |ch| channel = ch }
     Capistrano::Command.new("ls", [session])
+    assert_equal "capistrano", channel[:host]
   end
 
   def test_open_channel_should_set_options_key_on_channel
-    session = mock(:xserver => server("capistrano"))
-    channel = stub_everything
-
-    session.expects(:open_channel).yields(channel)
-    channel.expects(:[]=).with(:options, {:data => "here we go"})
-
+    channel = nil
+    session = setup_for_extracting_channel_action { |ch| channel = ch }
     Capistrano::Command.new("ls", [session], :data => "here we go")
-  end
-
-  def test_open_channel_should_request_pty
-    session = mock(:xserver => server("capistrano"))
-    channel = stub_everything
-
-    session.expects(:open_channel).yields(channel)
-    channel.expects(:request_pty).with(:want_reply => true)
-
-    Capistrano::Command.new("ls", [session])
+    assert_equal({ :data => 'here we go' }, channel[:options])
   end
 
   def test_successful_channel_should_send_command
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(sh -c "ls"))
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(sh -c 'ls'))
     end
     Capistrano::Command.new("ls", [session])
   end
 
   def test_successful_channel_with_shell_option_should_send_command_via_specified_shell
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(/bin/bash -c "ls"))
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(/bin/bash -c 'ls'))
     end
     Capistrano::Command.new("ls", [session], :shell => "/bin/bash")
   end
 
+  def test_successful_channel_with_shell_false_should_send_command_without_shell
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(echo `hostname`))
+    end
+    Capistrano::Command.new("echo `hostname`", [session], :shell => false)
+  end
+
   def test_successful_channel_should_send_data_if_data_key_is_present
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(sh -c "ls"))
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(sh -c 'ls'))
       ch.expects(:send_data).with("here we go")
     end
     Capistrano::Command.new("ls", [session], :data => "here we go")
   end
 
-  def test_unsuccessful_channel_should_close_channel
-    session = setup_for_extracting_channel_action(:on_failure) do |ch|
+  def test_unsuccessful_pty_request_should_close_channel
+    session = setup_for_extracting_channel_action(:request_pty, false) do |ch|
       ch.expects(:close)
     end
-    Capistrano::Command.new("ls", [session])
+    Capistrano::Command.new("ls", [session], :pty => true)
   end
 
   def test_on_data_should_invoke_callback_as_stdout
@@ -150,48 +148,58 @@ class CommandTest < Test::Unit::TestCase
 
   def test_on_request_should_record_exit_status
     data = mock(:read_long => 5)
-    session = setup_for_extracting_channel_action(:on_request, "exit-status", nil, data) do |ch|
-      ch.expects(:[]=).with(:status, 5)
-    end
+    channel = nil
+    session = setup_for_extracting_channel_action([:on_request, "exit-status"], data) { |ch| channel = ch }
     Capistrano::Command.new("ls", [session])
+    assert_equal 5, channel[:status]
+  end
+
+  def test_on_request_should_log_exit_signal_if_logger_present
+    data = mock(:read_string => "TERM")
+    logger = stub_everything
+
+    session = setup_for_extracting_channel_action([:on_request, "exit-signal"], data)
+    logger.expects(:important).with("command received signal TERM", server("capistrano"))
+
+    Capistrano::Command.new("puppet", [session], :logger => logger)
   end
 
   def test_on_close_should_set_channel_closed
-    session = setup_for_extracting_channel_action(:on_close) do |ch|
-      ch.expects(:[]=).with(:closed, true)
-    end
+    channel = nil
+    session = setup_for_extracting_channel_action(:on_close) { |ch| channel = ch }
     Capistrano::Command.new("ls", [session])
+    assert channel[:closed]
   end
 
   def test_stop_should_close_all_open_channels
-    sessions = [mock("session", :open_channel => new_channel(false)),
-                mock("session", :open_channel => new_channel(true)),
-                mock("session", :open_channel => new_channel(false))]
+    sessions = [mock_session(new_channel(false)),
+                mock_session(new_channel(true)),
+                mock_session(new_channel(false))]
 
     cmd = Capistrano::Command.new("ls", sessions)
     cmd.stop!
   end
 
   def test_process_should_return_cleanly_if_all_channels_have_zero_exit_status
-    sessions = [mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 0))]
+    sessions = [mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 0))]
     cmd = Capistrano::Command.new("ls", sessions)
     assert_nothing_raised { cmd.process! }
   end
 
   def test_process_should_raise_error_if_any_channel_has_non_zero_exit_status
-    sessions = [mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 1))]
+    sessions = [mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 1))]
     cmd = Capistrano::Command.new("ls", sessions)
     assert_raises(Capistrano::CommandError) { cmd.process! }
   end
 
   def test_command_error_should_include_accessor_with_host_array
-    sessions = [mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 1))]
+    sessions = [mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 1))]
     cmd = Capistrano::Command.new("ls", sessions)
 
     begin
@@ -207,95 +215,107 @@ class CommandTest < Test::Unit::TestCase
     new_channel = Proc.new do |times|
       ch = mock("channel")
       returns = [false] * (times-1)
+      ch.stubs(:to_ary)
       ch.stubs(:[]).with(:closed).returns(*(returns + [true]))
-      con = mock("connection")
-      con.expects(:process).with(true).times(times-1)
-      ch.expects(:connection).times(times-1).returns(con)
       ch.expects(:[]).with(:status).returns(0)
       ch
     end
 
-    sessions = [mock("session", :open_channel => new_channel[5]),
-                mock("session", :open_channel => new_channel[10]),
-                mock("session", :open_channel => new_channel[7])]
+    sessions = [mock_session(new_channel[5]),
+                mock_session(new_channel[10]),
+                mock_session(new_channel[7])]
     cmd = Capistrano::Command.new("ls", sessions)
-    assert_nothing_raised { cmd.process! }
-  end
-
-  def test_process_should_ping_all_connections_each_second
-    now = Time.now
-
-    new_channel = Proc.new do
-      ch = mock("channel")
-      ch.stubs(:now => now)
-      def ch.[](key)
-        case key
-        when :status then 0
-        when :closed then Time.now - now < 1.1 ? false : true
-        else raise "unknown key: #{key}"
-        end
-      end
-      con = mock("connection")
-      con.stubs(:process)
-      con.expects(:ping!)
-      ch.stubs(:connection).returns(con)
-      ch
+    assert_nothing_raised do
+      cmd.process!
     end
-
-    sessions = [mock("session", :open_channel => new_channel[]),
-                mock("session", :open_channel => new_channel[]),
-                mock("session", :open_channel => new_channel[])]
-    cmd = Capistrano::Command.new("ls", sessions)
-    assert_nothing_raised { cmd.process! }
   end
 
   def test_process_should_instantiate_command_and_process!
     cmd = mock("command", :process! => nil)
-    Capistrano::Command.expects(:new).with("ls -l", %w(a b c), {:foo => "bar"}).yields(:command).returns(cmd)
-    parameter = nil
-    Capistrano::Command.process("ls -l", %w(a b c), :foo => "bar") { |cmd| parameter = cmd }
-    assert_equal :command, parameter
+    Capistrano::Command.expects(:new).with("ls -l", %w(a b c), {:foo => "bar"}).returns(cmd)
+    Capistrano::Command.process("ls -l", %w(a b c), :foo => "bar")
   end
 
-  def test_process_with_host_placeholder_should_substitute_placeholder_with_each_host
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(sh -c "echo capistrano"))
+  def test_process_with_host_placeholder_should_substitute_host_placeholder_with_each_host
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(sh -c 'echo capistrano'))
     end
     Capistrano::Command.new("echo $CAPISTRANO:HOST$", [session])
   end
 
+  class MockConfig
+    include Capistrano::Configuration::Roles
+  end
+
+  def test_hostroles_substitution
+    @config = MockConfig.new
+    @config.server "capistrano", :db, :worker
+    server = @config.roles[:db].servers.first
+    channel = {:server => server, :host => 'capistrano'}
+    tree = Capistrano::Command::Tree.new(@config) { |t| t.else("echo $CAPISTRANO:HOSTROLES$") }
+    result = Capistrano::Command.new(tree, []).send(:replace_placeholders, "echo $CAPISTRANO:HOSTROLES$", channel)
+    assert result == "echo db,worker" || result == "echo worker,db"
+  end
+
   def test_process_with_unknown_placeholder_should_not_replace_placeholder
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:exec).with(%(sh -c "echo \\$CAPISTRANO:OTHER\\$"))
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(sh -c 'echo $CAPISTRANO:OTHER$'))
     end
     Capistrano::Command.new("echo $CAPISTRANO:OTHER$", [session])
   end
 
+  def test_input_stream_closed_when_eof_option_is_true
+    channel = nil
+    session = setup_for_extracting_channel_action { |ch| channel = ch }
+    channel.expects(:eof!)
+    Capistrano::Command.new("cat", [session], :data => "here we go", :eof => true)
+    assert_equal({ :data => 'here we go', :eof => true }, channel[:options])
+  end
+
   private
 
+    def mock_session(channel=nil)
+      stub('session',
+           :open_channel => channel,
+           :preprocess   => true,
+           :postprocess  => true,
+           :listeners    => {},
+           :xserver      => server("capistrano"))
+    end
+
+    class MockChannel < Hash
+      def close
+      end
+    end
+
     def new_channel(closed, status=nil)
-      ch = mock("channel")
-      ch.expects(:[]).with(:closed).returns(closed)
-      ch.expects(:[]).with(:status).returns(status) if status
+      ch = MockChannel.new
+      ch.update({ :closed => closed, :host => "capistrano", :server => server("capistrano") })
+      ch[:status] = status if status
       ch.expects(:close) unless closed
-      ch.stubs(:[]).with(:host).returns("capistrano")
-      ch.stubs(:[]).with(:server).returns(server("capistrano"))
       ch
     end
 
-    def setup_for_extracting_channel_action(action, *args)
+    def setup_for_extracting_channel_action(action=nil, *args)
       s = server("capistrano")
       session = mock("session", :xserver => s)
 
-      channel = stub_everything
+      channel = {}
       session.expects(:open_channel).yields(channel)
 
-      ch = mock
-      ch.stubs(:[]).with(:server).returns(s)
-      ch.stubs(:[]).with(:host).returns(s.host)
-      channel.expects(action).yields(ch, *args)
+      channel.stubs(:on_data)
+      channel.stubs(:on_extended_data)
+      channel.stubs(:on_request)
+      channel.stubs(:on_close)
+      channel.stubs(:exec)
+      channel.stubs(:send_data)
+
+      if action
+        action = Array(action)
+        channel.expects(action.first).with(*action[1..-1]).yields(channel, *args)
+      end
 
-      yield ch if block_given?
+      yield channel if block_given?
 
       session
     end

data/test/configuration/actions/file_transfer_test.rb

@@ -1,9 +1,10 @@
-require "#{File.dirname(__FILE__)}/../../utils"
+require "utils"
 require 'capistrano/configuration/actions/file_transfer'
 
 class ConfigurationActionsFileTransferTest < Test::Unit::TestCase
   class MockConfig
     include Capistrano::Configuration::Actions::FileTransfer
+    attr_accessor :sessions, :dry_run
   end
 
   def setup
@@ -11,30 +12,50 @@ class ConfigurationActionsFileTransferTest < Test::Unit::TestCase
     @config.stubs(:logger).returns(stub_everything)
   end
 
-  def test_put_should_pass_options_to_execute_on_servers
-    @config.expects(:execute_on_servers).with(:foo => "bar")
-    @config.put("some data", "test.txt", :foo => "bar")
+  def test_put_should_delegate_to_upload
+    @config.expects(:upload).with { |from, to, opts|
+      from.string == "some data" && to == "test.txt" && opts == { :mode => 0777 } }
+    @config.expects(:run).never
+    @config.put("some data", "test.txt", :mode => 0777)
   end
 
-  def test_put_should_delegate_to_Upload_process
-    @config.expects(:execute_on_servers).yields(%w(s1 s2 s3).map { |s| mock(:host => s) })
-    @config.expects(:sessions).times(3).returns(Hash.new{|h,k| h[k] = k.host.to_sym})
-    Capistrano::Upload.expects(:process).with([:s1,:s2,:s3], "test.txt", :data => "some data", :mode => 0777, :logger => @config.logger)
-    @config.put("some data", "test.txt", :mode => 0777)
+  def test_get_should_delegate_to_download_with_once
+    @config.expects(:download).with("testr.txt", "testl.txt", :foo => "bar", :once => true)
+    @config.get("testr.txt", "testl.txt", :foo => "bar")
   end
 
-  def test_get_should_pass_options_execute_on_servers_including_once
-    @config.expects(:execute_on_servers).with(:foo => "bar", :once => true)
-    @config.get("test.txt", "test.txt", :foo => "bar")
+  def test_upload_should_delegate_to_transfer
+    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
+    @config.upload("testl.txt", "testr.txt", :foo => "bar")
   end
 
-  def test_get_should_use_sftp_get_file_to_local_path
-    sftp = mock("sftp", :state => :closed, :connect => true)
-    sftp.expects(:get_file).with("remote.txt", "local.txt")
+  def test_upload_without_mode_should_not_try_to_chmod
+    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
+    @config.expects(:run).never
+    @config.upload("testl.txt", "testr.txt", :foo => "bar")
+  end
+
+  def test_upload_with_mode_should_try_to_chmod
+    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
+    @config.expects(:run).with("chmod 775 testr.txt", {:foo => "bar"})
+    @config.upload("testl.txt", "testr.txt", :mode => 0775, :foo => "bar")
+  end
+
+  def test_upload_with_symbolic_mode_should_try_to_chmod
+    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
+    @config.expects(:run).with("chmod g+w testr.txt", {:foo => "bar"})
+    @config.upload("testl.txt", "testr.txt", :mode => "g+w", :foo => "bar")
+  end
+
+  def test_download_should_delegate_to_transfer
+    @config.expects(:transfer).with(:down, "testr.txt", "testl.txt", :foo => "bar")
+    @config.download("testr.txt", "testl.txt", :foo => "bar")
+  end
 
-    s = server("capistrano")
-    @config.expects(:execute_on_servers).yields([s])
-    @config.expects(:sessions).returns(s => mock("session", :sftp => sftp))
-    @config.get("remote.txt", "local.txt")
+  def test_transfer_should_invoke_transfer_on_matching_servers
+    @config.sessions = { :a => 1, :b => 2, :c => 3, :d => 4 }
+    @config.expects(:execute_on_servers).with(:foo => "bar").yields([:a, :b, :c])
+    Capistrano::Transfer.expects(:process).with(:up, "testl.txt", "testr.txt", [1,2,3], {:foo => "bar", :logger => @config.logger})
+    @config.transfer(:up, "testl.txt", "testr.txt", :foo => "bar")
   end
-end
+end

data/test/configuration/actions/inspect_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../../utils"
+require "utils"
 require 'capistrano/configuration/actions/inspect'
 
 class ConfigurationActionsInspectTest < Test::Unit::TestCase
@@ -9,13 +9,19 @@ class ConfigurationActionsInspectTest < Test::Unit::TestCase
   def setup
     @config = MockConfig.new
     @config.stubs(:logger).returns(stub_everything)
+    @config.stubs(:sudo).returns('sudo')
   end
 
   def test_stream_should_pass_options_through_to_run
-    @config.expects(:invoke_command).with("tail -f foo.log", :once => true)
+    @config.expects(:invoke_command).with("tail -f foo.log", :once => true, :eof => true)
     @config.stream("tail -f foo.log", :once => true)
   end
 
+  def test_stream_with_sudo_should_avoid_closing_stdin
+    @config.expects(:invoke_command).with("sudo tail -f foo.log", :once => true, :eof => false)
+    @config.stream("sudo tail -f foo.log", :once => true)
+  end
+
   def test_stream_should_emit_stdout_via_puts
     @config.expects(:invoke_command).yields(mock("channel"), :out, "something streamed")
     @config.expects(:puts).with("something streamed")
@@ -33,13 +39,21 @@ class ConfigurationActionsInspectTest < Test::Unit::TestCase
   end
 
   def test_capture_should_pass_options_merged_with_once_to_run
-    @config.expects(:invoke_command).with("hostname", :foo => "bar", :once => true)
+    @config.expects(:invoke_command).with("hostname", :foo => "bar", :once => true, :eof => true)
     @config.capture("hostname", :foo => "bar")
   end
 
-  def test_capture_with_stderr_result_should_raise_capture_error
-    @config.expects(:invoke_command).yields(mock("channel"), :err, "boom")
-    assert_raises(Capistrano::CaptureError) { @config.capture("hostname") }
+  def test_capture_with_sudo_should_avoid_closing_stdin
+    @config.expects(:invoke_command).with("sudo hostname", :foo => "bar", :once => true, :eof => false)
+    @config.capture("sudo hostname", :foo => "bar")
+  end
+
+  def test_capture_with_stderr_should_emit_stderr_via_warn
+    ch = mock("channel")
+    ch.expects(:[]).with(:server).returns(server("capistrano"))
+    @config.expects(:invoke_command).yields(ch, :err, "boom")
+    @config.expects(:warn).with("[err :: capistrano] boom")
+    @config.capture("hostname")
   end
 
   def test_capture_with_stdout_should_aggregate_and_return_stdout
@@ -59,4 +73,4 @@ class ConfigurationActionsInspectTest < Test::Unit::TestCase
       @config.channel = channel
       @config.script = output
     end
-end
+end