capistrano 1.4.2 → 2.0.0

data/test/shell_test.rb

@@ -0,0 +1,64 @@
+require "#{File.dirname(__FILE__)}/utils"
+require 'capistrano/configuration'
+require 'capistrano/shell'
+
+class ShellTest < Test::Unit::TestCase
+  def setup
+    @config = Capistrano::Configuration.new
+    @shell  = Capistrano::Shell.new(@config)
+    @shell.stubs(:puts)
+  end
+
+  def test_readline_fallback_prompt_should_write_to_stdout_and_read_from_stdin
+    STDOUT.expects(:print).with("prompt> ")
+    STDOUT.expects(:flush)
+    STDIN.expects(:gets).returns("hi\n")
+    assert_equal "hi\n", Capistrano::Shell::ReadlineFallback.readline("prompt> ")
+  end
+
+  def test_question_mark_as_input_should_trigger_help
+    @shell.expects(:read_line).returns("?")
+    @shell.expects(:help)
+    assert @shell.read_and_execute
+  end
+
+  def test_help_as_input_should_trigger_help
+    @shell.expects(:read_line).returns("help")
+    @shell.expects(:help)
+    assert @shell.read_and_execute
+  end
+
+  def test_quit_as_input_should_cause_read_and_execute_to_return_false
+    @shell.expects(:read_line).returns("quit")
+    assert !@shell.read_and_execute
+  end
+
+  def test_exit_as_input_should_cause_read_and_execute_to_return_false
+    @shell.expects(:read_line).returns("exit")
+    assert !@shell.read_and_execute
+  end
+
+  def test_set_should_parse_flag_and_value_and_call_set_option
+    @shell.expects(:read_line).returns("set -v 5")
+    @shell.expects(:set_option).with("v", "5")
+    assert @shell.read_and_execute
+  end
+
+  def test_text_without_with_or_on_gets_processed_verbatim
+    @shell.expects(:read_line).returns("hello world")
+    @shell.expects(:process_command).with(nil, nil, "hello world")
+    assert @shell.read_and_execute
+  end
+
+  def test_text_with_with_gets_processed_with_with # lol
+    @shell.expects(:read_line).returns("with app,db hello world")
+    @shell.expects(:process_command).with("with", "app,db", "hello world")
+    assert @shell.read_and_execute
+  end
+
+  def test_text_with_on_gets_processed_with_on
+    @shell.expects(:read_line).returns("on app,db hello world")
+    @shell.expects(:process_command).with("on", "app,db", "hello world")
+    assert @shell.read_and_execute
+  end
+end

data/test/ssh_test.rb

@@ -1,184 +1,97 @@
-$:.unshift File.dirname(__FILE__) + "/../lib"
-
-require File.dirname(__FILE__) + "/utils"
-require 'test/unit'
+require "#{File.dirname(__FILE__)}/utils"
 require 'capistrano/ssh'
 
 class SSHTest < Test::Unit::TestCase
-  class MockSSH
-    AuthenticationFailed = Net::SSH::AuthenticationFailed
-
-    class <<self
-      attr_accessor :story
-      attr_accessor :invocations
-    end
+  def setup
+    @options = { :username => nil,
+                 :password => nil,
+                 :port     => 22,
+                 :auth_methods => %w(publickey hostbased) }
+    @server = server("capistrano")
+  end
 
-    def self.start(server, opts, &block)
-      @invocations << [server, opts, block]
-      err = story.shift
-      raise err if err
-    end
+  def test_connect_with_bare_server_without_options_or_config_with_public_key_succeeding_should_only_loop_once
+    Net::SSH.expects(:start).with(@server.host, @options).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(@server)
   end
 
-  def setup
-    @config = MockConfiguration.new
-    @config[:user] = 'demo'
-    @config[:password] = 'c0c0nutfr0st1ng'
-    MockSSH.story = []
-    MockSSH.invocations = []
+  def test_connect_with_bare_server_without_options_with_public_key_failing_should_try_password
+    Net::SSH.expects(:start).with(@server.host, @options).raises(Net::SSH::AuthenticationFailed)
+    Net::SSH.expects(:start).with(@server.host, @options.merge(:password => "f4b13n", :auth_methods => %w(password keyboard-interactive))).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(@server, :password => "f4b13n")
   end
 
-  def test_publickey_auth_succeeds_default_port_no_block
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('demo.server.i', @config)
+  def test_connect_with_bare_server_without_options_public_key_and_password_failing_should_raise_error
+    Net::SSH.expects(:start).with(@server.host, @options).raises(Net::SSH::AuthenticationFailed)
+    Net::SSH.expects(:start).with(@server.host, @options.merge(:password => "f4b13n", :auth_methods => %w(password keyboard-interactive))).raises(Net::SSH::AuthenticationFailed)
+    assert_raises(Net::SSH::AuthenticationFailed) do
+      Capistrano::SSH.connect(@server, :password => "f4b13n")
     end
-
-    assert_equal 1, MockSSH.invocations.length
-    assert_equal 'demo.server.i', MockSSH.invocations.first[0]
-    assert_equal 22, MockSSH.invocations.first[1][:port]
-    assert_equal 'demo', MockSSH.invocations.first[1][:username]
-    assert_nil MockSSH.invocations.first[1][:password]
-    assert_equal %w(publickey hostbased),
-      MockSSH.invocations.first[1][:auth_methods]
-    assert_nil MockSSH.invocations.first[2]
   end
-  
-  def test_explicit_ssh_ports_in_server_string_no_block
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('demo.server.i:8088', @config)
-    end
 
-    assert_equal 1, MockSSH.invocations.length
-    assert_equal 'demo.server.i', MockSSH.invocations.first[0]
-    assert_equal '8088', MockSSH.invocations.first[1][:port]
-    assert_equal 'demo', MockSSH.invocations.first[1][:username]
+  def test_connect_with_bare_server_and_user_via_public_key_should_pass_user_to_net_ssh
+    Net::SSH.expects(:start).with(@server.host, @options.merge(:username => "jamis")).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(@server, :user => "jamis")
   end
-  
-  def test_explicit_ssh_username_in_server_string_no_block
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('bob@demo.server.i', @config)
-    end
 
-    assert_equal 1, MockSSH.invocations.length
-    assert_equal 'demo.server.i', MockSSH.invocations.first[0]
-    assert_equal 22, MockSSH.invocations.first[1][:port]
-    assert_equal 'bob', MockSSH.invocations.first[1][:username]
+  def test_connect_with_bare_server_and_user_via_password_should_pass_user_to_net_ssh
+    Net::SSH.expects(:start).with(@server.host, @options.merge(:username => "jamis")).raises(Net::SSH::AuthenticationFailed)
+    Net::SSH.expects(:start).with(@server.host, @options.merge(:username => "jamis", :password => "f4b13n", :auth_methods => %w(password keyboard-interactive))).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(@server, :user => "jamis", :password => "f4b13n")
   end
-  
-  def test_explicit_ssh_username_and_port_in_server_string_no_block
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('bob@demo.server.i:8088', @config)
-    end
 
-    assert_equal 1, MockSSH.invocations.length
-    assert_equal 'demo.server.i', MockSSH.invocations.first[0]
-    assert_equal '8088', MockSSH.invocations.first[1][:port]
-    assert_equal 'bob', MockSSH.invocations.first[1][:username]
+  def test_connect_with_bare_server_with_explicit_port_should_pass_port_to_net_ssh
+    Net::SSH.expects(:start).with(@server.host, @options.merge(:port => 1234)).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(@server, :port => 1234)
   end
 
-  def test_publickey_auth_succeeds_explicit_port_no_block
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('demo.server.i', @config, 23)
-    end
-
-    assert_equal 1, MockSSH.invocations.length
-    assert_equal 23, MockSSH.invocations.first[1][:port]
-    assert_nil MockSSH.invocations.first[2]
+  def test_connect_with_server_with_user_should_pass_user_to_net_ssh
+    server = server("jamis@capistrano")
+    Net::SSH.expects(:start).with(server.host, @options.merge(:username => "jamis")).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(server)
   end
 
-
-  def test_explicit_ssh_ports_in_server_string_with_block
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('demo.server.i:8088', @config) do |session|
-      end
-    end
-    assert_equal 'demo.server.i', MockSSH.invocations.first[0]
-    assert_equal '8088', MockSSH.invocations.first[1][:port]
-    assert_equal 1, MockSSH.invocations.length
-    assert_instance_of Proc, MockSSH.invocations.first[2]
-  end
-  
-  def test_explicit_ssh_username_in_server_string_with_block
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('bob@demo.server.i', @config) do |session|
-      end
-    end
-    assert_equal 'demo.server.i', MockSSH.invocations.first[0]
-    assert_equal 22, MockSSH.invocations.first[1][:port]
-    assert_equal 1, MockSSH.invocations.length
-    assert_equal 'bob', MockSSH.invocations.first[1][:username]
-    assert_instance_of Proc, MockSSH.invocations.first[2]
-  end
-  
-  def test_explicit_ssh_username_and_port_in_server_string_with_block
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('bob@demo.server.i:8088', @config) do |session|
-      end
-    end
-    assert_equal 'demo.server.i', MockSSH.invocations.first[0]
-    assert_equal '8088', MockSSH.invocations.first[1][:port]
-    assert_equal 1, MockSSH.invocations.length
-    assert_equal 'bob', MockSSH.invocations.first[1][:username]
-    assert_instance_of Proc, MockSSH.invocations.first[2]
+  def test_connect_with_server_with_port_should_pass_port_to_net_ssh
+    server = server("capistrano:1235")
+    Net::SSH.expects(:start).with(server.host, @options.merge(:port => 1235)).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(server)
   end
 
-  def test_parse_server
-    assert_equal(['bob', 'demo.server.i', '8088'], 
-                 Capistrano::SSH.parse_server("bob@demo.server.i:8088"))
-    assert_equal([nil, 'demo.server.i', '8088'], 
-                 Capistrano::SSH.parse_server("demo.server.i:8088"))                 
-    assert_equal(['bob', 'demo.server.i', nil], 
-                 Capistrano::SSH.parse_server("bob@demo.server.i"))
-    assert_equal([nil, 'demo.server.i', nil], 
-                 Capistrano::SSH.parse_server("demo.server.i"))
-  end  
-
-  def test_publickey_auth_succeeds_with_block
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('demo.server.i', @config) do |session|
-      end
-    end
-
-    assert_equal 1, MockSSH.invocations.length
-    assert_instance_of Proc, MockSSH.invocations.first[2]
+  def test_connect_with_server_with_user_and_port_should_pass_user_and_port_to_net_ssh
+    server = server("jamis@capistrano:1235")
+    Net::SSH.expects(:start).with(server.host, @options.merge(:username => "jamis", :port => 1235)).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(server)
   end
 
-  def test_publickey_auth_fails
-    MockSSH.story << Net::SSH::AuthenticationFailed
-
-    Net.const_during(:SSH, MockSSH) do
-      Capistrano::SSH.connect('demo.server.i', @config)
-    end
-
-    assert_equal 2, MockSSH.invocations.length
-
-    assert_nil MockSSH.invocations.first[1][:password]
-    assert_equal %w(publickey hostbased),
-      MockSSH.invocations.first[1][:auth_methods]
-
-    assert_equal 'c0c0nutfr0st1ng', MockSSH.invocations.last[1][:password]
-    assert_equal %w(password keyboard-interactive),
-      MockSSH.invocations.last[1][:auth_methods]
+  def test_connect_with_ssh_options_should_use_ssh_options
+    ssh_options = { :username => "JamisMan", :port => 8125 }
+    Net::SSH.expects(:start).with(@server.host, @options.merge(:username => "JamisMan", :port => 8125)).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(@server, {:ssh_options => ssh_options})
   end
 
-  def test_password_auth_fails
-    MockSSH.story << Net::SSH::AuthenticationFailed
-    MockSSH.story << Net::SSH::AuthenticationFailed
-
-    Net.const_during(:SSH, MockSSH) do
-      assert_raises(Net::SSH::AuthenticationFailed) do
-        Capistrano::SSH.connect('demo.server.i', @config)
-      end
-    end
+  def test_connect_with_options_and_ssh_options_should_see_options_override_ssh_options
+    ssh_options = { :username => "JamisMan", :port => 8125, :forward_agent => true }
+    Net::SSH.expects(:start).with(@server.host, @options.merge(:username => "jamis", :port => 1235, :forward_agent => true)).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(@server, {:ssh_options => ssh_options, :user => "jamis", :port => 1235})
+  end
 
-    assert_equal 2, MockSSH.invocations.length
+  def test_connect_with_ssh_options_should_see_server_options_override_ssh_options
+    ssh_options = { :username => "JamisMan", :port => 8125, :forward_agent => true }
+    server = server("jamis@capistrano:1235")
+    Net::SSH.expects(:start).with(server.host, @options.merge(:username => "jamis", :port => 1235, :forward_agent => true)).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(server, {:ssh_options => ssh_options})
+  end
 
-    assert_nil MockSSH.invocations.first[1][:password]
-    assert_equal %w(publickey hostbased),
-      MockSSH.invocations.first[1][:auth_methods]
+  def test_connect_should_add_xserver_accessor_to_connection
+    Net::SSH.expects(:start).with(@server.host, @options).returns(success = Object.new)
+    assert_equal success, Capistrano::SSH.connect(@server)
+    assert success.respond_to?(:xserver)
+    assert success.respond_to?(:xserver)
+    assert_equal success.xserver, @server
+  end
 
-    assert_equal 'c0c0nutfr0st1ng', MockSSH.invocations.last[1][:password]
-    assert_equal %w(password keyboard-interactive),
-      MockSSH.invocations.last[1][:auth_methods]
+  def test_connect_should_not_retry_if_custom_auth_methods_are_given
+    Net::SSH.expects(:start).with(@server.host, @options.merge(:auth_methods => %w(publickey))).raises(Net::SSH::AuthenticationFailed)
+    assert_raises(Net::SSH::AuthenticationFailed) { Capistrano::SSH.connect(@server, :ssh_options => { :auth_methods => %w(publickey) }) }
   end
 end

data/test/task_definition_test.rb

@@ -0,0 +1,101 @@
+require "#{File.dirname(__FILE__)}/utils"
+require 'capistrano/task_definition'
+
+class TaskDefinitionTest < Test::Unit::TestCase
+  def setup
+    @namespace = namespace
+  end
+
+  def test_fqn_at_top_level_should_be_task_name
+    task = new_task(:testing)
+    assert_equal "testing", task.fully_qualified_name
+  end
+
+  def test_fqn_in_namespace_should_include_namespace_fqn
+    ns = namespace("outer:inner")
+    task = new_task(:testing, ns)
+    assert_equal "outer:inner:testing", task.fully_qualified_name
+  end
+
+  def test_fqn_at_top_level_when_default_should_be_default
+    task = new_task(:default)
+    assert_equal "default", task.fully_qualified_name
+  end
+
+  def test_fqn_in_namespace_when_default_should_be_namespace_fqn
+    ns = namespace("outer:inner")
+    task = new_task(:default, ns)
+    ns.stubs(:default_task => task)
+    assert_equal "outer:inner", task.fully_qualified_name
+  end
+
+  def test_task_should_require_block
+    assert_raises(ArgumentError) do
+      Capistrano::TaskDefinition.new(:testing, @namespace)
+    end
+  end
+
+  def test_description_should_return_empty_string_if_not_given
+    assert_equal "", new_task(:testing).description
+  end
+
+  def test_description_should_return_desc_attribute
+    assert_equal "something", new_task(:testing, @namespace, :desc => "something").description
+  end
+
+  def test_description_should_strip_leading_and_trailing_whitespace
+    assert_equal "something", new_task(:testing, @namespace, :desc => "   something   ").description
+  end
+
+  def test_description_should_normalize_newlines
+    assert_equal "a\nb\nc", new_task(:testing, @namespace, :desc => "a\nb\r\nc").description
+  end
+
+  def test_description_should_detect_and_remove_indentation
+    desc = <<-DESC
+      Here is some indented text \
+      and I want all of this to \
+      run together on a single line, \
+      without any extraneous spaces.
+
+        additional indentation will
+        be preserved.
+    DESC
+
+    task = new_task(:testing, @namespace, :desc => desc)
+    assert_equal "Here is some indented text and I want all of this to run together on a single line, without any extraneous spaces.\n\n  additional indentation will\n  be preserved.", task.description
+  end
+
+  def test_description_munging_should_be_sensitive_to_code_blocks
+    desc = <<-DESC
+      Here is a line \
+      wrapped      with spacing in it.
+
+        foo         bar
+        baz         bang
+    DESC
+
+    task = new_task(:testing, @namespace, :desc => desc)
+    assert_equal "Here is a line wrapped with spacing in it.\n\n  foo         bar\n  baz         bang", task.description
+  end
+
+  def test_brief_description_should_return_first_sentence_in_description
+    desc = "This is the task. It does all kinds of things."
+    task = new_task(:testing, @namespace, :desc => desc)
+    assert_equal "This is the task.", task.brief_description
+  end
+
+  def test_brief_description_should_truncate_if_length_given
+    desc = "This is the task that does all kinds of things. And then some."
+    task = new_task(:testing, @namespace, :desc => desc)
+    assert_equal "This is the task ...", task.brief_description(20)
+  end
+
+  def test_brief_description_should_not_break_at_period_in_middle_of_sentence
+    task = new_task(:testing, @namespace, :desc => "Take file.txt and copy it.")
+    assert_equal "Take file.txt and copy it.", task.brief_description
+
+    task = new_task(:testing, @namespace, :desc => "Take file.txt and copy it. Then do something else.")
+    assert_equal "Take file.txt and copy it.", task.brief_description
+  end
+end

data/test/upload_test.rb

@@ -0,0 +1,131 @@
+require "#{File.dirname(__FILE__)}/utils"
+require 'capistrano/upload'
+
+class UploadTest < Test::Unit::TestCase
+  def setup
+    @mode = IO::WRONLY | IO::CREAT | IO::TRUNC
+  end
+
+  def test_initialize_should_raise_error_if_data_is_missing
+    assert_raises(ArgumentError) do
+      Capistrano::Upload.new([], "test.txt", :foo => "bar")
+    end
+  end
+
+  def test_initialize_should_get_sftp_for_each_session
+    new_sftp = Proc.new do |state|
+      sftp = mock("sftp", :state => state, :open => nil)
+      sftp.expects(:connect) unless state == :open
+      sftp.stubs(:channel).returns({})
+      sftp
+    end
+
+    sessions = [mock("session", :xserver => server("a"), :sftp => new_sftp[:closed]),
+                mock("session", :xserver => server("b"), :sftp => new_sftp[:closed]),
+                mock("session", :xserver => server("c"), :sftp => new_sftp[:open])]
+    Capistrano::Upload.new(sessions, "test.txt", :data => "data")
+  end
+
+  def test_self_process_should_instantiate_uploader_and_start_process
+    Capistrano::Upload.expects(:new).with([:s1, :s2], "test.txt", :data => "data").returns(mock(:process! => nil))
+    Capistrano::Upload.process([:s1, :s2], "test.txt", :data => "data")
+  end
+
+  def test_process_when_sftp_open_fails_should_raise_error
+    sftp = mock_sftp
+    sftp.expects(:open).with("test.txt", @mode, 0660).yields(mock("status", :code => "bad status", :message => "bad status"), :file_handle)
+    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
+    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
+    assert_raises(Capistrano::UploadError) { upload.process! }
+    assert_equal 1, upload.failed
+    assert_equal 1, upload.completed
+  end
+
+  def test_process_when_sftp_write_fails_should_raise_error
+    sftp = mock_sftp
+    sftp.expects(:open).with("test.txt", @mode, 0660).yields(mock("status1", :code => Net::SFTP::Session::FX_OK), :file_handle)
+    sftp.expects(:write).with(:file_handle, "data").yields(mock("status2", :code => "bad status", :message => "bad status"))
+    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
+    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
+    assert_raises(Capistrano::UploadError) { upload.process! }
+    assert_equal 1, upload.failed
+    assert_equal 1, upload.completed
+  end
+  
+  def test_upload_error_should_include_accessor_with_host_array
+    sftp = mock_sftp
+    sftp.expects(:open).with("test.txt", @mode, 0660).yields(mock("status1", :code => Net::SFTP::Session::FX_OK), :file_handle)
+    sftp.expects(:write).with(:file_handle, "data").yields(mock("status2", :code => "bad status", :message => "bad status"))
+    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
+    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
+    
+    begin
+      upload.process!
+      flunk "expected an exception to be raised"
+    rescue Capistrano::UploadError => e
+      assert e.respond_to?(:hosts)
+      assert_equal %w(capistrano), e.hosts.map { |h| h.to_s }
+    end
+  end
+  
+  def test_process_when_sftp_succeeds_should_raise_nothing
+    sftp = mock_sftp
+    sftp.expects(:open).with("test.txt", @mode, 0660).yields(mock("status1", :code => Net::SFTP::Session::FX_OK), :file_handle)
+    sftp.expects(:write).with(:file_handle, "data").yields(mock("status2", :code => Net::SFTP::Session::FX_OK))
+    sftp.expects(:close_handle).with(:file_handle).yields
+    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
+    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
+    assert_nothing_raised { upload.process! }
+    assert_equal 0, upload.failed
+    assert_equal 1, upload.completed
+  end
+
+  def test_process_should_loop_while_running
+    con = mock("connection")
+    con.expects(:process).with(true).times(10)
+    channel = {}
+    channel.expects(:connection).returns(con).times(10)
+    sftp = mock("sftp", :state => :open, :open => nil)
+    sftp.stubs(:channel).returns(channel)
+    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
+    upload = Capistrano::Upload.new([session], "test.txt", :data => "data")
+    upload.expects(:running?).times(11).returns(*([true]*10 + [false]))
+    upload.process!
+  end
+
+  def test_process_should_loop_but_not_process_done_channels
+    new_sftp = Proc.new do |done|
+      channel = {}
+      channel[:needs_done] = done
+
+      if !done
+        con = mock("connection")
+        con.expects(:process).with(true).times(10)
+        channel.expects(:connection).returns(con).times(10)
+      end
+
+      sftp = mock("sftp", :state => :open, :open => nil)
+      sftp.stubs(:channel).returns(channel)
+      sftp
+    end
+
+    sessions = [stub("session", :sftp => new_sftp[true], :xserver => server("capistrano")),
+                stub("session", :sftp => new_sftp[false], :xserver => server("cap2"))]
+    upload = Capistrano::Upload.new(sessions, "test.txt", :data => "data")
+
+    # make sure the sftp channels we wanted to be done, start as done
+    # (Upload.new marks each channel as not-done, so we have to do it here)
+    sessions.each { |s| s.sftp.channel[:done] = true if s.sftp.channel[:needs_done] }
+    upload.expects(:running?).times(11).returns(*([true]*10 + [false]))
+    upload.process!
+  end
+
+  private
+
+    def mock_sftp
+      sftp = mock("sftp", :state => :open)
+      sftp.stubs(:channel).returns(Hash.new)
+      yield sftp if block_given?
+      sftp
+    end
+end