capistrano 2.1.0 → 3.0.0

data/test/configuration/callbacks_test.rb

@@ -1,206 +0,0 @@
-require "#{File.dirname(__FILE__)}/../utils"
-require 'capistrano/configuration/callbacks'
-
-class ConfigurationCallbacksTest < Test::Unit::TestCase
-  class MockConfig
-    attr_reader :original_initialize_called
-    attr_reader :called
-
-    def initialize
-      @original_initialize_called = true
-      @called = []
-    end
-
-    def execute_task(task)
-      @called << task
-    end
-
-    include Capistrano::Configuration::Callbacks
-  end
-
-  def setup
-    @config = MockConfig.new
-    @config.stubs(:logger).returns(stub_everything("logger"))
-  end
-
-  def test_initialize_should_initialize_callbacks_collection
-    assert @config.original_initialize_called
-    assert @config.callbacks.empty?
-  end
-
-  def test_before_should_delegate_to_on
-    @config.expects(:on).with(:before, :foo, "bing:blang", {:only => :bar, :zip => :zing})
-    @config.before :bar, :foo, "bing:blang", :zip => :zing
-  end
-
-  def test_after_should_delegate_to_on
-    @config.expects(:on).with(:after, :foo, "bing:blang", {:only => :bar, :zip => :zing})
-    @config.after :bar, :foo, "bing:blang", :zip => :zing
-  end
-
-  def test_on_with_single_reference_should_add_task_callback
-    @config.on :before, :a_test
-    assert_equal 1, @config.callbacks[:before].length
-    assert_equal :a_test, @config.callbacks[:before][0].source
-    @config.expects(:find_and_execute_task).with(:a_test)
-    @config.callbacks[:before][0].call
-  end
-
-  def test_on_with_multi_reference_should_add_all_as_task_callback
-    @config.on :before, :first, :second, :third
-    assert_equal 3, @config.callbacks[:before].length
-    assert_equal %w(first second third), @config.callbacks[:before].map { |c| c.source.to_s }
-  end
-
-  def test_on_with_block_should_add_block_as_proc_callback
-    called = false
-    @config.on(:before) { called = true }
-    assert_equal 1, @config.callbacks[:before].length
-    assert_instance_of Proc, @config.callbacks[:before][0].source
-    @config.callbacks[:before][0].call
-    assert called
-  end
-
-  def test_on_with_single_only_should_set_only_as_string_array_on_all_references
-    @config.on :before, :first, "second:third", :only => :primary
-    assert_equal 2, @config.callbacks[:before].length
-    assert @config.callbacks[:before].all? { |c| c.only == %w(primary) }
-  end
-
-  def test_on_with_multi_only_should_set_only_as_string_array_on_all_references
-    @config.on :before, :first, "second:third", :only => [:primary, "other:one"]
-    assert_equal 2, @config.callbacks[:before].length
-    assert @config.callbacks[:before].all? { |c| c.only == %w(primary other:one) }
-  end
-
-  def test_on_with_single_except_should_set_except_as_string_array_on_all_references
-    @config.on :before, :first, "second:third", :except => :primary
-    assert_equal 2, @config.callbacks[:before].length
-    assert @config.callbacks[:before].all? { |c| c.except == %w(primary) }
-  end
-
-  def test_on_with_multi_except_should_set_except_as_string_array_on_all_references
-    @config.on :before, :first, "second:third", :except => [:primary, "other:one"]
-    assert_equal 2, @config.callbacks[:before].length
-    assert @config.callbacks[:before].all? { |c| c.except == %w(primary other:one) }
-  end
-
-  def test_on_with_only_and_block_should_set_only_as_string_array
-    @config.on(:before, :only => :primary) { blah }
-    assert_equal 1, @config.callbacks[:before].length
-    assert_equal %w(primary), @config.callbacks[:before].first.only
-  end
-
-  def test_on_with_except_and_block_should_set_except_as_string_array
-    @config.on(:before, :except => :primary) { blah }
-    assert_equal 1, @config.callbacks[:before].length
-    assert_equal %w(primary), @config.callbacks[:before].first.except
-  end
-
-  def test_trigger_without_constraints_should_invoke_all_callbacks
-    task = stub(:fully_qualified_name => "any:old:thing")
-    @config.on(:before, :first, "second:third")
-    @config.on(:after, :another, "and:another")
-    @config.expects(:find_and_execute_task).with(:first)
-    @config.expects(:find_and_execute_task).with("second:third")
-    @config.expects(:find_and_execute_task).with(:another).never
-    @config.expects(:find_and_execute_task).with("and:another").never
-    @config.trigger(:before, task)
-  end
-
-  def test_trigger_with_only_constraint_should_invoke_only_matching_callbacks
-    task = stub(:fully_qualified_name => "any:old:thing")
-    @config.on(:before, :first)
-    @config.on(:before, "second:third", :only => "any:old:thing")
-    @config.on(:before, "this:too", :only => "any:other:thing")
-    @config.on(:after, :another, "and:another")
-    @config.expects(:find_and_execute_task).with(:first)
-    @config.expects(:find_and_execute_task).with("second:third")
-    @config.expects(:find_and_execute_task).with("this:too").never
-    @config.expects(:find_and_execute_task).with(:another).never
-    @config.expects(:find_and_execute_task).with("and:another").never
-    @config.trigger(:before, task)
-  end
-
-  def test_trigger_with_except_constraint_should_invoke_anything_but_matching_callbacks
-    task = stub(:fully_qualified_name => "any:old:thing")
-    @config.on(:before, :first)
-    @config.on(:before, "second:third", :except => "any:old:thing")
-    @config.on(:before, "this:too", :except => "any:other:thing")
-    @config.on(:after, :another, "and:another")
-    @config.expects(:find_and_execute_task).with(:first)
-    @config.expects(:find_and_execute_task).with("second:third").never
-    @config.expects(:find_and_execute_task).with("this:too")
-    @config.expects(:find_and_execute_task).with(:another).never
-    @config.expects(:find_and_execute_task).with("and:another").never
-    @config.trigger(:before, task)
-  end
-
-  def test_trigger_without_task_should_invoke_all_callbacks_for_that_event
-    task = stub(:fully_qualified_name => "any:old:thing")
-    @config.on(:before, :first)
-    @config.on(:before, "second:third", :except => "any:old:thing")
-    @config.on(:before, "this:too", :except => "any:other:thing")
-    @config.on(:after, :another, "and:another")
-    @config.expects(:find_and_execute_task).with(:first)
-    @config.expects(:find_and_execute_task).with("second:third")
-    @config.expects(:find_and_execute_task).with("this:too")
-    @config.expects(:find_and_execute_task).with(:another).never
-    @config.expects(:find_and_execute_task).with("and:another").never
-    @config.trigger(:before)
-  end
-
-  def test_execute_task_without_named_hooks_should_just_call_task
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-
-    @config.execute_task(task)
-    assert_equal [task], @config.called
-  end
-
-  def test_execute_task_with_named_before_hook_should_call_named_before_hook
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-    before_task = stub(:fully_qualified_name => "any:old:before_thing", :name => "before_thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-    ns.expects(:search_task).with("before_thing").returns(before_task)
-
-    @config.execute_task(task)
-    assert_equal [before_task, task], @config.called
-  end
-
-  def test_execute_task_with_named_after_hook_should_call_named_after_hook
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-    after_task = stub(:fully_qualified_name => "any:old:after_thing", :name => "after_thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-    ns.expects(:search_task).with("after_thing").returns(after_task)
-
-    @config.execute_task(task)
-    assert_equal [task, after_task], @config.called
-  end
-
-  def test_execute_task_with_on_hooks_should_trigger_hooks_around_task
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-    before_task = stub(:fully_qualified_name => "any:old:before_thing", :name => "before_thing", :namespace => ns)
-    after_task = stub(:fully_qualified_name => "any:old:after_thing", :name => "after_thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-    ns.expects(:search_task).with("before_thing").returns(before_task)
-    ns.expects(:search_task).with("after_thing").returns(after_task)
-
-    @config.before("any:old:thing", :first_this, :then_this)
-    @config.after("any:old:thing", :and_then_this, :lastly_this)
-
-    [:first_this, :then_this, :and_then_this, :lastly_this].each do |t|
-      @config.expects(:find_and_execute_task).with(t)
-    end
-
-    @config.execute_task(task)
-  end
-end

data/test/configuration/connections_test.rb

@@ -1,288 +0,0 @@
-require "#{File.dirname(__FILE__)}/../utils"
-require 'capistrano/configuration/connections'
-
-class ConfigurationConnectionsTest < Test::Unit::TestCase
-  class MockConfig
-    attr_reader :original_initialize_called
-    attr_reader :values
-    attr_accessor :current_task
-
-    def initialize
-      @original_initialize_called = true
-      @values = {}
-    end
-
-    def fetch(*args)
-      @values.fetch(*args)
-    end
-
-    def [](key)
-      @values[key]
-    end
-
-    def exists?(key)
-      @values.key?(key)
-    end
-
-    include Capistrano::Configuration::Connections
-  end
-
-  def setup
-    @config = MockConfig.new
-    @config.stubs(:logger).returns(stub_everything)
-    @ssh_options = {
-      :user        => "jamis",
-      :port        => 8080,
-      :password    => "g00b3r",
-      :ssh_options => { :debug => :verbose }
-    }
-  end
-
-  def test_initialize_should_initialize_collections_and_call_original_initialize
-    assert @config.original_initialize_called
-    assert @config.sessions.empty?
-  end
-
-  def test_connection_factory_should_return_default_connection_factory_instance
-    factory = @config.connection_factory
-    assert_instance_of Capistrano::Configuration::Connections::DefaultConnectionFactory, factory
-  end
-
-  def test_connection_factory_instance_should_be_cached
-    assert_same @config.connection_factory, @config.connection_factory
-  end
-
-  def test_default_connection_factory_honors_config_options
-    server = server("capistrano")
-    Capistrano::SSH.expects(:connect).with(server, @config).returns(:session)
-    assert_equal :session, @config.connection_factory.connect_to(server)
-  end
-
-  def test_connection_factory_should_return_gateway_instance_if_gateway_variable_is_set
-    @config.values[:gateway] = "capistrano"
-    server = server("capistrano")
-    Capistrano::SSH.expects(:connect).with { |s,| s.host == "capistrano" }.yields(stub_everything)
-    assert_instance_of Capistrano::Gateway, @config.connection_factory
-  end
-
-  def test_connection_factory_as_gateway_should_honor_config_options
-    @config.values[:gateway] = "capistrano"
-    @config.values.update(@ssh_options)
-    Capistrano::SSH.expects(:connect).with { |s,opts| s.host == "capistrano" && opts == @config }.yields(stub_everything)
-    assert_instance_of Capistrano::Gateway, @config.connection_factory
-  end
-
-  def test_establish_connections_to_should_accept_a_single_nonarray_parameter
-    Capistrano::SSH.expects(:connect).with { |s,| s.host == "capistrano" }.returns(:success)
-    assert @config.sessions.empty?
-    @config.establish_connections_to(server("capistrano"))
-    assert ["capistrano"], @config.sessions.keys
-  end
-
-  def test_establish_connections_to_should_accept_an_array
-    Capistrano::SSH.expects(:connect).times(3).returns(:success)
-    assert @config.sessions.empty?
-    @config.establish_connections_to(%w(cap1 cap2 cap3).map { |s| server(s) })
-    assert %w(cap1 cap2 cap3), @config.sessions.keys.sort
-  end
-
-  def test_establish_connections_to_should_not_attempt_to_reestablish_existing_connections
-    Capistrano::SSH.expects(:connect).times(2).returns(:success)
-    @config.sessions[server("cap1")] = :ok
-    @config.establish_connections_to(%w(cap1 cap2 cap3).map { |s| server(s) })
-    assert %w(cap1 cap2 cap3), @config.sessions.keys.sort.map { |s| s.host }
-  end
-  
-  def test_establish_connections_to_should_raise_one_connection_error_on_failure
-    Capistrano::SSH.expects(:connect).times(2).raises(Exception)
-    assert_raises(Capistrano::ConnectionError) {
-      @config.establish_connections_to(%w(cap1 cap2).map { |s| server(s) })
-    }
-  end
-
-  def test_connection_error_should_include_accessor_with_host_array
-    Capistrano::SSH.expects(:connect).times(2).raises(Exception)
-
-    begin
-      @config.establish_connections_to(%w(cap1 cap2).map { |s| server(s) })
-      flunk "expected an exception to be raised"
-    rescue Capistrano::ConnectionError => e
-      assert e.respond_to?(:hosts)
-      assert_equal %w(cap1 cap2), e.hosts.map { |h| h.to_s }
-    end
-  end
-  
-  def test_connection_error_should_only_include_failed_hosts
-    Capistrano::SSH.expects(:connect).times(2).raises(Exception).then.returns(:success)
-
-    begin
-      @config.establish_connections_to(%w(cap1 cap2).map { |s| server(s) })
-      flunk "expected an exception to be raised"
-    rescue Capistrano::ConnectionError => e
-      assert_equal %w(cap1), e.hosts.map { |h| h.to_s }
-    end
-  end
-
-  def test_execute_on_servers_should_require_a_block
-    assert_raises(ArgumentError) { @config.execute_on_servers }
-  end
-
-  def test_execute_on_servers_without_current_task_should_call_find_servers
-    list = [server("first"), server("second")]
-    @config.expects(:find_servers).with(:a => :b, :c => :d).returns(list)
-    @config.expects(:establish_connections_to).with(list).returns(:done)
-    @config.execute_on_servers(:a => :b, :c => :d) do |result|
-      assert_equal list, result
-    end
-  end
-
-  def test_execute_on_servers_without_current_task_should_raise_error_if_no_matching_servers
-    @config.expects(:find_servers).with(:a => :b, :c => :d).returns([])
-    assert_raises(Capistrano::NoMatchingServersError) { @config.execute_on_servers(:a => :b, :c => :d) { |list| } }
-  end
-
-  def test_execute_on_servers_should_raise_an_error_if_the_current_task_has_no_matching_servers_by_default
-    @config.current_task = mock_task
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([])
-    assert_raises(Capistrano::NoMatchingServersError) do
-      @config.execute_on_servers do
-        flunk "should not get here"
-      end
-    end
-  end
-  
-  def test_execute_on_servers_should_determine_server_list_from_active_task
-    assert @config.sessions.empty?
-    @config.current_task = mock_task
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1"), server("cap2"), server("cap3")])
-    Capistrano::SSH.expects(:connect).times(3).returns(:success)
-    @config.execute_on_servers {}
-    assert_equal %w(cap1 cap2 cap3), @config.sessions.keys.sort.map { |s| s.host }
-  end
-
-  def test_execute_on_servers_should_yield_server_list_to_block
-    assert @config.sessions.empty?
-    @config.current_task = mock_task
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1"), server("cap2"), server("cap3")])
-    Capistrano::SSH.expects(:connect).times(3).returns(:success)
-    block_called = false
-    @config.execute_on_servers do |servers|
-      block_called = true
-      assert servers.detect { |s| s.host == "cap1" }
-      assert servers.detect { |s| s.host == "cap2" }
-      assert servers.detect { |s| s.host == "cap3" }
-      assert servers.all? { |s| @config.sessions[s] }
-    end
-    assert block_called
-  end
-
-  def test_execute_on_servers_with_once_option_should_establish_connection_to_and_yield_only_the_first_server
-    assert @config.sessions.empty?
-    @config.current_task = mock_task
-    @config.expects(:find_servers_for_task).with(@config.current_task, :once => true).returns([server("cap1"), server("cap2"), server("cap3")])
-    Capistrano::SSH.expects(:connect).returns(:success)
-    block_called = false
-    @config.execute_on_servers(:once => true) do |servers|
-      block_called = true
-      assert_equal %w(cap1), servers.map { |s| s.host }
-    end
-    assert block_called
-    assert_equal %w(cap1), @config.sessions.keys.sort.map { |s| s.host }
-  end
-  
-  def test_execute_servers_should_raise_connection_error_on_failure_by_default
-    @config.current_task = mock_task
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1")])
-    Capistrano::SSH.expects(:connect).raises(Exception)
-    assert_raises(Capistrano::ConnectionError) {
-      @config.execute_on_servers do
-        flunk "expected an exception to be raised"
-      end
-    }
-  end
-  
-  def test_execute_servers_should_not_raise_connection_error_on_failure_with_on_errors_continue
-    @config.current_task = mock_task(:on_error => :continue)
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1"), server("cap2")])
-    Capistrano::SSH.expects(:connect).times(2).raises(Exception).then.returns(:success)
-    assert_nothing_raised {
-      @config.execute_on_servers do |servers|
-        assert_equal %w(cap2), servers.map { |s| s.host }
-      end
-    }
-  end
-  
-  def test_execute_on_servers_should_not_try_to_connect_to_hosts_with_connection_errors_with_on_errors_continue
-    list = [server("cap1"), server("cap2")]
-    @config.current_task = mock_task(:on_error => :continue)
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns(list)
-    Capistrano::SSH.expects(:connect).times(2).raises(Exception).then.returns(:success)
-    @config.expects(:failed!).with(server("cap1"))
-    @config.execute_on_servers do |servers|
-      assert_equal %w(cap2), servers.map { |s| s.host }
-    end
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns(list)
-    @config.execute_on_servers do |servers|
-      assert_equal %w(cap2), servers.map { |s| s.host }
-    end
-  end
-  
-  def test_execute_on_servers_should_not_try_to_connect_to_hosts_with_command_errors_with_on_errors_continue
-    cap1 = server("cap1")
-    cap2 = server("cap2")
-    @config.current_task = mock_task(:on_error => :continue)
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2])
-    Capistrano::SSH.expects(:connect).times(2).returns(:success)
-    @config.execute_on_servers do |servers|
-      error = Capistrano::CommandError.new
-      error.hosts = [cap1]
-      raise error
-    end
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2])
-    @config.execute_on_servers do |servers|
-      assert_equal %w(cap2), servers.map { |s| s.host }
-    end
-  end
-  
-  def test_execute_on_servers_should_not_try_to_connect_to_hosts_with_upload_errors_with_on_errors_continue
-    cap1 = server("cap1")
-    cap2 = server("cap2")
-    @config.current_task = mock_task(:on_error => :continue)
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2])
-    Capistrano::SSH.expects(:connect).times(2).returns(:success)
-    @config.execute_on_servers do |servers|
-      error = Capistrano::UploadError.new
-      error.hosts = [cap1]
-      raise error
-    end
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2])
-    @config.execute_on_servers do |servers|
-      assert_equal %w(cap2), servers.map { |s| s.host }
-    end
-  end
-
-  def test_connect_should_establish_connections_to_all_servers_in_scope
-    assert @config.sessions.empty?
-    @config.current_task = mock_task
-    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1"), server("cap2"), server("cap3")])
-    Capistrano::SSH.expects(:connect).times(3).returns(:success)
-    @config.connect!
-    assert_equal %w(cap1 cap2 cap3), @config.sessions.keys.sort.map { |s| s.host }
-  end
-
-  def test_connect_should_honor_once_option
-    assert @config.sessions.empty?
-    @config.current_task = mock_task
-    @config.expects(:find_servers_for_task).with(@config.current_task, :once => true).returns([server("cap1"), server("cap2"), server("cap3")])
-    Capistrano::SSH.expects(:connect).returns(:success)
-    @config.connect! :once => true
-    assert_equal %w(cap1), @config.sessions.keys.sort.map { |s| s.host }
-  end
-
-  private
-
-    def mock_task(options={})
-      continue_on_error = options[:on_error] == :continue
-      stub("task", :fully_qualified_name => "name", :options => options, :continue_on_error? => continue_on_error)
-    end
-end

data/test/configuration/execution_test.rb

@@ -1,159 +0,0 @@
-require "#{File.dirname(__FILE__)}/../utils"
-require 'capistrano/configuration/execution'
-require 'capistrano/task_definition'
-
-class ConfigurationExecutionTest < Test::Unit::TestCase
-  class MockConfig
-    attr_reader :tasks, :namespaces, :fully_qualified_name, :parent
-    attr_reader :state, :original_initialize_called
-    attr_accessor :logger, :default_task
-
-    def initialize(options={})
-      @original_initialize_called = true
-      @tasks = {}
-      @namespaces = {}
-      @state = {}
-      @fully_qualified_name = options[:fqn]
-      @parent = options[:parent]
-      @logger = options.delete(:logger)
-    end
-
-    include Capistrano::Configuration::Execution
-  end
-
-  def setup
-    @config = MockConfig.new(:logger => stub(:debug => nil, :info => nil, :important => nil))
-    @config.stubs(:search_task).returns(nil)
-  end
-
-  def test_initialize_should_initialize_collections
-    assert_nil @config.rollback_requests
-    assert @config.original_initialize_called
-    assert @config.task_call_frames.empty?
-  end
-
-  def test_execute_task_should_populate_call_stack
-    task = new_task @config, :testing
-    assert_nothing_raised { @config.execute_task(task) }
-    assert_equal %w(testing), @config.state[:testing][:stack]
-    assert_nil @config.state[:testing][:history]
-    assert @config.task_call_frames.empty?
-  end
-
-  def test_nested_execute_task_should_add_to_call_stack
-    testing = new_task @config, :testing
-    outer = new_task(@config, :outer) { execute_task(testing) }
-
-    assert_nothing_raised { @config.execute_task(outer) }
-    assert_equal %w(outer testing), @config.state[:testing][:stack]
-    assert_nil @config.state[:testing][:history]
-    assert @config.task_call_frames.empty?
-  end
-
-  def test_execute_task_should_execute_in_scope_of_tasks_parent
-    ns = stub("namespace", :tasks => {}, :default_task => nil, :fully_qualified_name => "ns")
-    ns.expects(:instance_eval)
-    testing = new_task ns, :testing
-    @config.execute_task(testing)
-  end
-
-  def test_transaction_outside_of_task_should_raise_exception
-    assert_raises(ScriptError) { @config.transaction {} }
-  end
-
-  def test_transaction_without_block_should_raise_argument_error
-    testing = new_task(@config, :testing) { transaction }
-    assert_raises(ArgumentError) { @config.execute_task(testing) }
-  end
-
-  def test_transaction_should_initialize_transaction_history
-    @config.state[:inspector] = stack_inspector
-    testing = new_task(@config, :testing) { transaction { instance_eval(&state[:inspector]) } }
-    @config.execute_task(testing)
-    assert_equal [], @config.state[:testing][:history]
-  end
-
-  def test_transaction_from_within_transaction_should_not_start_new_transaction
-    third = new_task(@config, :third, &stack_inspector)
-    second = new_task(@config, :second) { transaction { execute_task(third) } }
-    first = new_task(@config, :first) { transaction { execute_task(second) } }
-    # kind of fragile...not sure how else to check that transaction was only
-    # really run twice...but if the transaction was REALLY run, logger.info
-    # will be called once when it starts, and once when it finishes.
-    @config.logger = mock()
-    @config.logger.stubs(:debug)
-    @config.logger.expects(:info).times(2)
-    @config.execute_task(first)
-  end
-
-  def test_on_rollback_should_have_no_effect_outside_of_transaction
-    aaa = new_task(@config, :aaa) { on_rollback { state[:rollback] = true }; raise "boom" }
-    assert_raises(RuntimeError) { @config.execute_task(aaa) }
-    assert_nil @config.state[:rollback]
-  end
-
-  def test_exception_raised_in_transaction_should_call_all_registered_rollback_handlers_in_reverse_order
-    aaa = new_task(@config, :aaa) { on_rollback { (state[:rollback] ||= []) << :aaa } }
-    bbb = new_task(@config, :bbb) { on_rollback { (state[:rollback] ||= []) << :bbb } }
-    ccc = new_task(@config, :ccc) {}
-    ddd = new_task(@config, :ddd) { on_rollback { (state[:rollback] ||= []) << :ddd }; execute_task(bbb); execute_task(ccc) }
-    eee = new_task(@config, :eee) { transaction { execute_task(ddd); execute_task(aaa); raise "boom" } }
-    assert_raises(RuntimeError) do
-      @config.execute_task(eee)
-    end
-    assert_equal [:aaa, :bbb, :ddd], @config.state[:rollback]
-    assert_nil @config.rollback_requests
-    assert @config.task_call_frames.empty?
-  end
-
-  def test_exception_during_rollback_should_simply_be_logged_and_ignored
-    aaa = new_task(@config, :aaa) { on_rollback { state[:aaa] = true; raise LoadError, "ouch" }; execute_task(bbb) }
-    bbb = new_task(@config, :bbb) { raise MadError, "boom" }
-    ccc = new_task(@config, :ccc) { transaction { execute_task(aaa) } }
-    assert_raises(NameError) do
-      @config.execute_task(ccc)
-    end
-    assert @config.state[:aaa]
-  end
-
-  def test_find_and_execute_task_should_raise_error_when_task_cannot_be_found
-    @config.expects(:find_task).with("path:to:task").returns(nil)
-    assert_raises(Capistrano::NoSuchTaskError) { @config.find_and_execute_task("path:to:task") }
-  end
-
-  def test_find_and_execute_task_should_execute_task_when_task_is_found
-    @config.expects(:find_task).with("path:to:task").returns(:found)
-    @config.expects(:execute_task).with(:found)
-    assert_nothing_raised { @config.find_and_execute_task("path:to:task") }
-  end
-
-  def test_find_and_execute_task_with_before_option_should_trigger_callback
-    @config.expects(:find_task).with("path:to:task").returns(:found)
-    @config.expects(:trigger).with(:incoming, :found)
-    @config.expects(:execute_task).with(:found)
-    @config.find_and_execute_task("path:to:task", :before => :incoming)
-  end
-
-  def test_find_and_execute_task_with_after_option_should_trigger_callback
-    @config.expects(:find_task).with("path:to:task").returns(:found)
-    @config.expects(:trigger).with(:outgoing, :found)
-    @config.expects(:execute_task).with(:found)
-    @config.find_and_execute_task("path:to:task", :after => :outgoing)
-  end
-
-  private
-
-    def stack_inspector
-      Proc.new do
-        (state[:trail] ||= []) << current_task.fully_qualified_name
-        data = state[current_task.name] = {}
-        data[:stack] = task_call_frames.map { |frame| frame.task.fully_qualified_name }
-        data[:history] = rollback_requests && rollback_requests.map { |frame| frame.task.fully_qualified_name }
-      end
-    end
-
-    def new_task(namespace, name, options={}, &block)
-      block ||= stack_inspector
-      namespace.tasks[name] = Capistrano::TaskDefinition.new(name, namespace, &block)
-    end
-end