capistrano 2.15.11 → 3.0.0.pre

data/test/cli/options_test.rb

@@ -1,329 +0,0 @@
-require "utils"
-require 'capistrano/cli/options'
-
-class CLIOptionsTest < Test::Unit::TestCase
-  class ExitException < Exception; end
-
-  class MockCLI
-    def initialize
-      @args = []
-    end
-
-    attr_reader :args
-
-    include Capistrano::CLI::Options
-  end
-
-  def setup
-    @cli = MockCLI.new
-  end
-
-  def test_parse_options_should_require_non_empty_args_list
-    @cli.stubs(:warn)
-    @cli.expects(:exit).raises(ExitException)
-    assert_raises(ExitException) { @cli.parse_options! }
-  end
-
-  def test_parse_options_with_d_should_set_debug_option
-    @cli.args << "-d"
-    @cli.parse_options!
-    assert @cli.options[:debug]
-  end
-
-  def test_parse_options_with_n_should_set_dry_run_option
-    @cli.args << "-n"
-    @cli.parse_options!
-    assert @cli.options[:dry_run]
-  end
-
-  def test_parse_options_with_dry_run_should_set_dry_run_option
-    @cli.args << "--dry-run"
-    @cli.parse_options!
-    assert @cli.options[:dry_run]
-  end
-
-  def test_parse_options_with_e_should_set_explain_option
-    @cli.args << "-e" << "sample"
-    @cli.parse_options!
-    assert_equal "sample", @cli.options[:explain]
-  end
-
-  def test_parse_options_with_f_should_add_recipe_file
-    @cli.args << "-f" << "deploy"
-    @cli.parse_options!
-    assert_equal %w(deploy), @cli.options[:recipes]
-  end
-
-  def test_parse_options_with_multiple_f_should_add_each_as_recipe_file
-    @cli.args << "-f" << "deploy" << "-f" << "monitor"
-    @cli.parse_options!
-    assert_equal %w(deploy monitor), @cli.options[:recipes]
-  end
-
-  def test_parse_options_with_H_should_show_verbose_help_and_exit
-    @cli.expects(:exit).raises(ExitException)
-    @cli.expects(:long_help)
-    @cli.args << "-H"
-    assert_raises(ExitException) { @cli.parse_options! }
-  end
-
-  def test_parse_options_with_h_should_show_options_and_exit
-    @cli.expects(:puts).with(@cli.option_parser)
-    @cli.expects(:exit).raises(ExitException)
-    @cli.args << "-h"
-    assert_raises(ExitException) { @cli.parse_options! }
-  end
-
-  def test_parse_options_with_p_should_prompt_for_password
-    MockCLI.expects(:password_prompt).returns(:the_password)
-    @cli.args << "-p"
-    @cli.parse_options!
-    assert_equal :the_password, @cli.options[:password]
-  end
-
-  def test_parse_options_without_p_should_set_proc_for_password
-    @cli.args << "-e" << "sample"
-    @cli.parse_options!
-    assert_instance_of Proc, @cli.options[:password]
-  end
-
-  def test_parse_options_with_q_should_set_verbose_to_0
-    @cli.args << "-q"
-    @cli.parse_options!
-    assert_equal 0, @cli.options[:verbose]
-  end
-
-  def test_parse_options_with_r_should_set_preserve_roles_option
-    @cli.args << "-r"
-    @cli.parse_options!
-    assert @cli.options[:preserve_roles]
-  end
-
-  def test_parse_options_with_preserve_roles_should_set_preserve_roles_option
-    @cli.args << "--preserve-roles"
-    @cli.parse_options!
-    assert @cli.options[:preserve_roles]
-  end
-
-  def test_parse_options_with_S_should_set_pre_vars
-    @cli.args << "-S" << "foo=bar"
-    @cli.parse_options!
-    assert_equal "bar", @cli.options[:pre_vars][:foo]
-  end
-
-  def test_S_should_coerce_digits_to_integers
-    @cli.args << "-S" << "foo=1234"
-    @cli.parse_options!
-    assert_equal 1234, @cli.options[:pre_vars][:foo]
-  end
-
-  def test_S_should_treat_quoted_integers_as_string
-    @cli.args << "-S" << "foo=\"1234\""
-    @cli.parse_options!
-    assert_equal "1234", @cli.options[:pre_vars][:foo]
-  end
-
-  def test_S_should_treat_digits_with_dot_as_floating_point
-    @cli.args << "-S" << "foo=3.1415"
-    @cli.parse_options!
-    assert_equal 3.1415, @cli.options[:pre_vars][:foo]
-  end
-
-  def test_S_should_treat_true_as_boolean_true
-    @cli.args << "-S" << "foo=true"
-    @cli.parse_options!
-    assert_equal true, @cli.options[:pre_vars][:foo]
-  end
-
-  def test_S_should_treat_false_as_boolean_false
-    @cli.args << "-S" << "foo=false"
-    @cli.parse_options!
-    assert_equal false, @cli.options[:pre_vars][:foo]
-  end
-
-  def test_S_should_treat_nil_as_nil
-    @cli.args << "-S" << "foo=nil"
-    @cli.parse_options!
-    assert_equal nil, @cli.options[:pre_vars][:foo]
-  end
-
-  def test_parse_options_with_s_should_set_vars
-    @cli.args << "-s" << "foo=bar"
-    @cli.parse_options!
-    assert_equal "bar", @cli.options[:vars][:foo]
-  end
-
-  def test_s_should_coerce_digits_to_integers
-    @cli.args << "-s" << "foo=1234"
-    @cli.parse_options!
-    assert_equal 1234, @cli.options[:vars][:foo]
-  end
-
-  def test_s_should_treat_quoted_integers_as_string
-    @cli.args << "-s" << "foo=\"1234\""
-    @cli.parse_options!
-    assert_equal "1234", @cli.options[:vars][:foo]
-  end
-
-  def test_s_should_treat_digits_with_dot_as_floating_point
-    @cli.args << "-s" << "foo=3.1415"
-    @cli.parse_options!
-    assert_equal 3.1415, @cli.options[:vars][:foo]
-  end
-
-  def test_s_should_treat_true_as_boolean_true
-    @cli.args << "-s" << "foo=true"
-    @cli.parse_options!
-    assert_equal true, @cli.options[:vars][:foo]
-  end
-
-  def test_s_should_treat_false_as_boolean_false
-    @cli.args << "-s" << "foo=false"
-    @cli.parse_options!
-    assert_equal false, @cli.options[:vars][:foo]
-  end
-
-  def test_s_should_treat_nil_as_nil
-    @cli.args << "-s" << "foo=nil"
-    @cli.parse_options!
-    assert_equal nil, @cli.options[:vars][:foo]
-  end
-
-  def test_parse_options_with_T_should_set_tasks_option_and_set_verbose_off
-    @cli.args << "-T"
-    @cli.parse_options!
-    assert @cli.options[:tasks]
-    assert_equal 0, @cli.options[:verbose]
-  end
-
-  def test_parse_options_with_V_should_show_version_and_exit
-    @cli.args << "-V"
-    @cli.expects(:puts).with { |s| s.include?(Capistrano::Version.to_s) }
-    @cli.expects(:exit).raises(ExitException)
-    assert_raises(ExitException) { @cli.parse_options! }
-  end
-
-  def test_parse_options_with_v_should_set_verbose_to_1
-    @cli.args << "-v"
-    @cli.parse_options!
-    assert_equal 1, @cli.options[:verbose]
-  end
-
-  def test_parse_options_with_multiple_v_should_set_verbose_accordingly
-    @cli.args << "-vvvvvvv"
-    @cli.parse_options!
-    assert_equal 7, @cli.options[:verbose]
-  end
-
-  def test_parse_options_without_X_should_set_sysconf
-    @cli.args << "-v"
-    @cli.parse_options!
-    assert @cli.options.key?(:sysconf)
-  end
-
-  def test_parse_options_with_X_should_unset_sysconf
-    @cli.args << "-X"
-    @cli.parse_options!
-    assert !@cli.options.key?(:sysconf)
-  end
-
-  def test_parse_options_without_x_should_set_dotfile
-    @cli.args << "-v"
-    @cli.parse_options!
-    assert @cli.options.key?(:dotfile)
-  end
-
-  def test_parse_options_with_x_should_unset_dotfile
-    @cli.args << "-x"
-    @cli.parse_options!
-    assert !@cli.options.key?(:dotfile)
-  end
-
-  def test_parse_options_without_q_or_v_should_set_verbose_to_3
-    @cli.args << "-x"
-    @cli.parse_options!
-    assert_equal 3, @cli.options[:verbose]
-  end
-
-  def test_should_search_for_default_recipes_if_f_not_given
-    @cli.expects(:look_for_default_recipe_file!)
-    @cli.args << "-v"
-    @cli.parse_options!
-  end
-
-  def test_should_not_search_for_default_recipes_if_f_given
-    @cli.expects(:look_for_default_recipe_file!).never
-    @cli.args << "-f" << "hello"
-    @cli.parse_options!
-  end
-
-  def test_F_should_search_for_default_recipes_even_if_f_is_given
-    @cli.expects(:look_for_default_recipe_file!)
-    @cli.args << "-Ff" << "hello"
-    @cli.parse_options!
-  end
-
-  def test_should_extract_env_vars_from_command_line
-    assert_nil ENV["HELLO"]
-    assert_nil ENV["ANOTHER"]
-
-    @cli.args << "HELLO=world" << "hello" << "ANOTHER=value"
-    @cli.parse_options!
-
-    assert_equal "world", ENV["HELLO"]
-    assert_equal "value", ENV["ANOTHER"]
-  ensure
-    ENV.delete("HELLO")
-    ENV.delete("ANOTHER")
-  end
-
-  def test_remaining_args_should_be_added_to_actions_list
-    @cli.args << "-v" << "HELLO=world" << "-f" << "foo" << "something" << "else"
-    @cli.parse_options!
-    assert_equal %w(something else), @cli.args
-  ensure
-    ENV.delete("HELLO")
-  end
-
-  def test_search_for_default_recipe_file_should_look_for_Capfile
-    File.stubs(:file?).returns(false)
-    File.expects(:file?).with("Capfile").returns(true)
-    @cli.args << "-v"
-    @cli.parse_options!
-    assert_equal %w(Capfile), @cli.options[:recipes]
-  end
-
-  def test_search_for_default_recipe_file_should_look_for_capfile
-    File.stubs(:file?).returns(false)
-    File.expects(:file?).with("capfile").returns(true)
-    @cli.args << "-v"
-    @cli.parse_options!
-    assert_equal %w(capfile), @cli.options[:recipes]
-  end
-
-  def test_search_for_default_recipe_should_hike_up_the_directory_tree_until_it_finds_default_recipe
-    File.stubs(:file?).returns(false)
-    File.expects(:file?).with("capfile").times(2).returns(false,true)
-    Dir.expects(:pwd).times(3).returns(*%w(/bar/baz /bar/baz /bar))
-    Dir.expects(:chdir).with("..")
-    @cli.args << "-v"
-    @cli.parse_options!
-    assert_equal %w(capfile), @cli.options[:recipes]
-  end
-
-  def test_search_for_default_recipe_should_halt_at_root_directory
-    File.stubs(:file?).returns(false)
-    Dir.expects(:pwd).times(7).returns(*%w(/bar/baz /bar/baz /bar /bar / / /))
-    Dir.expects(:chdir).with("..").times(3)
-    Dir.expects(:chdir).with("/bar/baz")
-    @cli.args << "-v"
-    @cli.parse_options!
-    assert @cli.options[:recipes].empty?
-  end
-
-  def test_parse_should_instantiate_new_cli_and_call_parse_options
-    cli = mock("cli", :parse_options! => nil)
-    MockCLI.expects(:new).with(%w(a b c)).returns(cli)
-    assert_equal cli, MockCLI.parse(%w(a b c))
-  end
-end

data/test/cli/ui_test.rb

@@ -1,28 +0,0 @@
-require "utils"
-require 'capistrano/cli/ui'
-
-class CLIUITest < Test::Unit::TestCase
-  class MockCLI
-    include Capistrano::CLI::UI
-  end
-
-  def test_ui_should_return_highline_instance
-    assert_instance_of HighLine, MockCLI.ui
-  end
-
-  def test_password_prompt_should_have_default_prompt_and_set_echo_false
-    q = mock("question")
-    q.expects(:echo=).with(false)
-    ui = mock("ui")
-    ui.expects(:ask).with("Password: ").yields(q).returns("sayuncle")
-    MockCLI.expects(:ui).returns(ui)
-    assert_equal "sayuncle", MockCLI.password_prompt
-  end
-
-  def test_password_prompt_with_custom_prompt_should_use_custom_prompt
-    ui = mock("ui")
-    ui.expects(:ask).with("Give the passphrase: ").returns("sayuncle")
-    MockCLI.expects(:ui).returns(ui)
-    assert_equal "sayuncle", MockCLI.password_prompt("Give the passphrase: ")
-  end
-end

data/test/cli_test.rb

@@ -1,17 +0,0 @@
-require "utils"
-require 'capistrano/cli'
-
-class CLI_Test < Test::Unit::TestCase
-  def test_options_ui_and_help_modules_should_integrate_successfully_with_configuration
-    cli = Capistrano::CLI.parse(%w(-T -x -X))
-    cli.expects(:puts).at_least_once
-    cli.execute!
-  end
-
-  def test_options_and_execute_modules_should_integrate_successfully_with_configuration
-    path = "#{File.dirname(__FILE__)}/fixtures/cli_integration.rb"
-    cli = Capistrano::CLI.parse(%W(-x -X -q -f #{path} testing))
-    config = cli.execute!
-    assert config[:testing_occurred]
-  end
-end

data/test/command_test.rb

@@ -1,322 +0,0 @@
-require "utils"
-require 'capistrano/command'
-require 'capistrano/configuration'
-
-class CommandTest < Test::Unit::TestCase
-  def test_command_should_open_channels_on_all_sessions
-    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_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_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 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 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 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 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 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 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'$/
-      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
-    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
-    channel = nil
-    session = setup_for_extracting_channel_action { |ch| channel = ch }
-    Capistrano::Command.new("ls", [session], :data => "here we go")
-    assert_equal({ :data => 'here we go' }, channel[:options])
-  end
-
-  def test_successful_channel_should_send_command
-    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 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 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_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], :pty => true)
-  end
-
-  def test_on_data_should_invoke_callback_as_stdout
-    session = setup_for_extracting_channel_action(:on_data, "hello")
-    called = false
-    Capistrano::Command.new("ls", [session]) do |ch, stream, data|
-      called = true
-      assert_equal :out, stream
-      assert_equal "hello", data
-    end
-    assert called
-  end
-
-  def test_on_extended_data_should_invoke_callback_as_stderr
-    session = setup_for_extracting_channel_action(:on_extended_data, 2, "hello")
-    called = false
-    Capistrano::Command.new("ls", [session]) do |ch, stream, data|
-      called = true
-      assert_equal :err, stream
-      assert_equal "hello", data
-    end
-    assert called
-  end
-
-  def test_on_request_should_record_exit_status
-    data = mock(:read_long => 5)
-    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
-    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(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(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(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(new_channel(true, 0)),
-                mock_session(new_channel(true, 0)),
-                mock_session(new_channel(true, 1))]
-    cmd = Capistrano::Command.new("ls", sessions)
-
-    begin
-      cmd.process!
-      flunk "expected an exception to be raised"
-    rescue Capistrano::CommandError => e
-      assert e.respond_to?(:hosts)
-      assert_equal %w(capistrano), e.hosts.map { |h| h.to_s }
-    end
-  end
-
-  def test_process_should_loop_until_all_channels_are_closed
-    new_channel = Proc.new do |times|
-      ch = mock("channel")
-      returns = [false] * (times-1)
-      ch.stubs(:to_ary)
-      ch.stubs(:[]).with(:closed).returns(*(returns + [true]))
-      ch.expects(:[]).with(:status).returns(0)
-      ch
-    end
-
-    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 do
-      cmd.process!
-    end
-  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"}).returns(cmd)
-    Capistrano::Command.process("ls -l", %w(a b c), :foo => "bar")
-  end
-
-  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 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 = MockChannel.new
-      ch.update({ :closed => closed, :host => "capistrano", :server => server("capistrano") })
-      ch[:status] = status if status
-      ch.expects(:close) unless closed
-      ch
-    end
-
-    def setup_for_extracting_channel_action(action=nil, *args)
-      s = server("capistrano")
-      session = mock("session", :xserver => s)
-
-      channel = {}
-      session.expects(:open_channel).yields(channel)
-
-      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 channel if block_given?
-
-      session
-    end
-end