capistrano 2.0.0 → 2.15.2

data/test/configuration/connections_test.rb

@@ -1,10 +1,11 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/connections'
 
 class ConfigurationConnectionsTest < Test::Unit::TestCase
   class MockConfig
     attr_reader :original_initialize_called
     attr_reader :values
+    attr_reader :dry_run
     attr_accessor :current_task
 
     def initialize
@@ -30,8 +31,9 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
   def setup
     @config = MockConfig.new
     @config.stubs(:logger).returns(stub_everything)
+    Net::SSH.stubs(:configuration_for).returns({})
     @ssh_options = {
-      :user        => "jamis",
+      :user        => "user",
       :port        => 8080,
       :password    => "g00b3r",
       :ssh_options => { :debug => :verbose }
@@ -58,65 +60,111 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
     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
+  def test_should_connect_through_gateway_if_gateway_variable_is_set
+    @config.values[:gateway] = "j@gateway"
+    Net::SSH::Gateway.expects(:new).with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
+    assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
   end
 
   def test_connection_factory_as_gateway_should_honor_config_options
-    @config.values[:gateway] = "capistrano"
+    @config.values[:gateway] = "gateway"
     @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
+    Net::SSH::Gateway.expects(:new).with("gateway", "user", :debug => :verbose, :port => 8080, :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
+    assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
+  end
+
+  def test_connection_factory_as_gateway_should_chain_gateways_if_gateway_variable_is_an_array
+    @config.values[:gateway] = ["j@gateway1", "k@gateway2"]
+    gateway1 = mock
+    Net::SSH::Gateway.expects(:new).with("gateway1", "j", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(gateway1)
+    gateway1.expects(:open).returns(65535)
+    Net::SSH::Gateway.expects(:new).with("127.0.0.1", "k", :port => 65535, :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
+    assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
+  end
+
+  def test_connection_factory_as_gateway_should_chain_gateways_if_gateway_variable_is_a_hash
+    @config.values[:gateway] = { ["j@gateway1", "k@gateway2"] => :default }
+    gateway1 = mock
+    Net::SSH::Gateway.expects(:new).with("gateway1", "j", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(gateway1)
+    gateway1.expects(:open).returns(65535)
+    Net::SSH::Gateway.expects(:new).with("127.0.0.1", "k", :port => 65535, :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
+    assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
+  end
+
+  def test_connection_factory_as_gateway_should_share_gateway_between_connections
+    @config.values[:gateway] = "j@gateway"
+    Net::SSH::Gateway.expects(:new).once.with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
+    Capistrano::SSH.stubs(:connect).returns(stub_everything)
+    assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
+    @config.establish_connections_to(server("capistrano"))
+    @config.establish_connections_to(server("another"))
+  end
+
+  def test_connection_factory_as_gateway_should_share_gateway_between_like_connections_if_gateway_variable_is_a_hash
+    @config.values[:gateway] = { "j@gateway" => [ "capistrano", "another"] }
+    Net::SSH::Gateway.expects(:new).once.with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
+    Capistrano::SSH.stubs(:connect).returns(stub_everything)
+    assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
+    @config.establish_connections_to(server("capistrano"))
+    @config.establish_connections_to(server("another"))
+  end
+
+  def test_connection_factory_as_gateways_should_not_share_gateway_between_unlike_connections_if_gateway_variable_is_a_hash
+    @config.values[:gateway] = { "j@gateway" => [ "capistrano", "another"], "k@gateway2" => "yafhost" }
+    Net::SSH::Gateway.expects(:new).once.with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
+    Net::SSH::Gateway.expects(:new).once.with("gateway2", "k", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
+    Capistrano::SSH.stubs(:connect).returns(stub_everything)
+    assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
+    @config.establish_connections_to(server("capistrano"))
+    @config.establish_connections_to(server("another"))
+    @config.establish_connections_to(server("yafhost"))
   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
+    assert_equal ["capistrano"], @config.sessions.keys.map(&:host)
   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
+    assert_equal %w(cap1 cap2 cap3), @config.sessions.keys.sort.map(&:host)
   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 }
+    assert_equal %w(cap1 cap2 cap3), @config.sessions.keys.sort.map(&: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| servers(s) }
+      @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| servers(s) }      
+      @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 }
+      assert_equal %w(cap1 cap2), e.hosts.map { |h| h.to_s }.sort
     end
   end
-  
+
   def test_connection_error_should_only_include_failed_hosts
-    Capistrano::SSH.expects(:connect).times(2).raises(Exception).then.returns(:success)
+    Capistrano::SSH.expects(:connect).with(server('cap1'), anything).raises(Exception)
+    Capistrano::SSH.expects(:connect).with(server('cap2'), anything).returns(:success)
 
     begin
-      @config.establish_connections_to(%w(cap1 cap2)).map { |s| servers(s) }      
+      @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 }
@@ -141,6 +189,11 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
     assert_raises(Capistrano::NoMatchingServersError) { @config.execute_on_servers(:a => :b, :c => :d) { |list| } }
   end
 
+  def test_execute_on_servers_without_current_task_should_not_raise_error_if_no_matching_servers_and_continue_on_no_matching_servers
+    @config.expects(:find_servers).with(:a => :b, :c => :d, :on_no_matching_servers => :continue).returns([])
+    assert_nothing_raised { @config.execute_on_servers(:a => :b, :c => :d, :on_no_matching_servers => :continue) { |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([])
@@ -150,7 +203,27 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
       end
     end
   end
-  
+
+  def test_execute_on_servers_should_not_raise_an_error_if_the_current_task_has_no_matching_servers_by_default_and_continue_on_no_matching_servers
+    @config.current_task = mock_task(:on_no_matching_servers => :continue)
+    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([])
+    assert_nothing_raised do
+      @config.execute_on_servers do
+        flunk "should not get here"
+      end
+    end
+  end
+
+  def test_execute_on_servers_should_not_raise_an_error_if_the_current_task_has_no_matching_servers_by_default_and_command_continues_on_no_matching_servers
+    @config.current_task = mock_task
+    @config.expects(:find_servers_for_task).with(@config.current_task, :on_no_matching_servers => :continue).returns([])
+    assert_nothing_raised do
+      @config.execute_on_servers(:on_no_matching_servers => :continue) 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
@@ -189,35 +262,36 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
     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) {
+    assert_raises(Capistrano::ConnectionError) do
       @config.execute_on_servers do
         flunk "expected an exception to be raised"
       end
-    }
+    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)
+    Capistrano::SSH.expects(:connect).with(server('cap1'), anything).raises(Exception)
+    Capistrano::SSH.expects(:connect).with(server('cap2'), anything).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"))
+    Capistrano::SSH.expects(:connect).with(server('cap1'), anything).raises(Exception)
+    Capistrano::SSH.expects(:connect).with(server('cap2'), anything).returns(:success)
     @config.execute_on_servers do |servers|
       assert_equal %w(cap2), servers.map { |s| s.host }
     end
@@ -226,7 +300,7 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
       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")
@@ -243,15 +317,15 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
       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
+
+  def test_execute_on_servers_should_not_try_to_connect_to_hosts_with_transfer_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 = Capistrano::TransferError.new
       error.hosts = [cap1]
       raise error
     end
@@ -270,6 +344,78 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
     assert_equal %w(cap1 cap2 cap3), @config.sessions.keys.sort.map { |s| s.host }
   end
 
+  def test_execute_on_servers_should_only_run_on_tasks_max_hosts_hosts_at_once
+    cap1 = server("cap1")
+    cap2 = server("cap2")
+    connection1 = mock()
+    connection2 = mock()
+    connection1.expects(:close)
+    connection2.expects(:close)
+    @config.current_task = mock_task(:max_hosts => 1)
+    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2])
+    Capistrano::SSH.expects(:connect).times(2).returns(connection1).then.returns(connection2)
+    block_called = 0
+    @config.execute_on_servers do |servers|
+      block_called += 1
+      assert_equal 1, servers.size
+    end
+    assert_equal 2, block_called
+  end
+
+  def test_execute_on_servers_should_only_run_on_max_hosts_hosts_at_once
+    cap1 = server("cap1")
+    cap2 = server("cap2")
+    connection1 = mock()
+    connection2 = mock()
+    connection1.expects(:close)
+    connection2.expects(:close)
+    @config.current_task = mock_task(:max_hosts => 1)
+    @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2])
+    Capistrano::SSH.expects(:connect).times(2).returns(connection1).then.returns(connection2)
+    block_called = 0
+    @config.execute_on_servers do |servers|
+      block_called += 1
+      assert_equal 1, servers.size
+    end
+    assert_equal 2, block_called
+  end
+
+  def test_execute_on_servers_should_cope_with_already_dropped_connections_when_attempting_to_close_them
+    cap1 = server("cap1")
+    cap2 = server("cap2")
+    connection1 = mock()
+    connection2 = mock()
+    connection3 = mock()
+    connection4 = mock()
+    connection1.expects(:close).raises(IOError)
+    connection2.expects(:close)
+    connection3.expects(:close)
+    connection4.expects(:close)
+    @config.current_task = mock_task(:max_hosts => 1)
+    @config.expects(:find_servers_for_task).times(2).with(@config.current_task, {}).returns([cap1, cap2])
+    Capistrano::SSH.expects(:connect).times(4).returns(connection1).then.returns(connection2).then.returns(connection3).then.returns(connection4)
+    @config.execute_on_servers {}
+    @config.execute_on_servers {}
+  end
+
+  def test_execute_on_servers_should_cope_with_already_disconnected_connections_when_attempting_to_close_them
+    cap1 = server("cap1")
+    cap2 = server("cap2")
+    connection1 = mock()
+    connection2 = mock()
+    connection3 = mock()
+    connection4 = mock()
+    connection1.expects(:close).raises(Net::SSH::Disconnect)
+    connection2.expects(:close)
+    connection3.expects(:close)
+    connection4.expects(:close)
+    @config.current_task = mock_task(:max_hosts => 1)
+    @config.expects(:find_servers_for_task).times(2).with(@config.current_task, {}).returns([cap1, cap2])
+    Capistrano::SSH.expects(:connect).times(4).returns(connection1).then.returns(connection2).then.returns(connection3).then.returns(connection4)
+    @config.execute_on_servers {}
+    @config.execute_on_servers {}
+  end
+
   def test_connect_should_honor_once_option
     assert @config.sessions.empty?
     @config.current_task = mock_task
@@ -283,6 +429,11 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
 
     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)
+      stub("task",
+        :fully_qualified_name => "name",
+        :options => options,
+        :continue_on_error? => continue_on_error,
+        :max_hosts => options[:max_hosts]
+      )
     end
-end
+end

data/test/configuration/execution_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/execution'
 require 'capistrano/task_definition'
 
@@ -116,6 +116,22 @@ class ConfigurationExecutionTest < Test::Unit::TestCase
     assert @config.state[:aaa]
   end
 
+  def test_on_rollback_called_twice_should_result_in_last_rollback_block_being_effective
+    aaa = new_task(@config, :aaa) do
+      transaction do
+        on_rollback { (state[:rollback] ||= []) << :first }
+        on_rollback { (state[:rollback] ||= []) << :second }
+        raise "boom"
+      end
+    end
+
+    assert_raises(RuntimeError) do
+      @config.execute_task(aaa)
+    end
+
+    assert_equal [:second], @config.state[:rollback]
+  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") }
@@ -156,4 +172,4 @@ class ConfigurationExecutionTest < Test::Unit::TestCase
       block ||= stack_inspector
       namespace.tasks[name] = Capistrano::TaskDefinition.new(name, namespace, &block)
     end
-end
+end

data/test/configuration/loading_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require 'utils'
 require 'capistrano/configuration/loading'
 
 class ConfigurationLoadingTest < Test::Unit::TestCase
@@ -23,7 +23,7 @@ class ConfigurationLoadingTest < Test::Unit::TestCase
 
   def teardown
     MockConfig.instance = nil
-    $".delete "#{File.dirname(__FILE__)}/../fixtures/custom.rb"
+    $LOADED_FEATURES.delete_if { |a| a =~ /fixtures\/custom\.rb$/ }
   end
 
   def test_initialize_should_init_collections
@@ -106,7 +106,7 @@ class ConfigurationLoadingTest < Test::Unit::TestCase
 
   def test_require_from_config_should_load_file_in_config_scope
     assert_nothing_raised do
-      @config.require "#{File.dirname(__FILE__)}/../fixtures/custom"
+      @config.require "#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom"
     end
     assert_equal :custom, @config.ping
   end
@@ -116,4 +116,17 @@ class ConfigurationLoadingTest < Test::Unit::TestCase
       require "#{File.dirname(__FILE__)}/../fixtures/custom"
     end
   end
-end
+
+  def test_require_from_config_should_return_false_when_called_a_second_time_with_same_args
+    assert @config.require("#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom")
+    assert_equal false, @config.require("#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom")
+  end
+
+  def test_require_in_multiple_instances_should_load_recipes_in_each_instance
+    config2 = MockConfig.new
+    @config.require "#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom"
+    config2.require "#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom"
+    assert_equal :custom, @config.ping
+    assert_equal :custom, config2.ping
+  end
+end

data/test/configuration/namespace_dsl_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/namespaces'
 
 class ConfigurationNamespacesDSLTest < Test::Unit::TestCase
@@ -108,9 +108,9 @@ class ConfigurationNamespacesDSLTest < Test::Unit::TestCase
   end
 
   def test_defining_ask_should_add_task_as_method
-    assert !@config.methods.include?("original")
+    assert !@config.methods.any? { |m| m.to_sym == :original }
     @config.task(:original) { puts "foo" }
-    assert @config.methods.include?("original")
+    assert @config.methods.any? { |m| m.to_sym == :original }
   end
 
   def test_calling_defined_task_should_delegate_to_execute_task
@@ -146,7 +146,7 @@ class ConfigurationNamespacesDSLTest < Test::Unit::TestCase
 
   def test_parent_for_namespace_should_be_the_top_level
     @config.namespace(:outer) {}
-    assert_equal @config, @config.namespaces[:outer].parent    
+    assert_equal @config, @config.namespaces[:outer].parent
   end
 
   def test_fqn_for_nested_namespace_should_be_color_delimited
@@ -239,6 +239,12 @@ class ConfigurationNamespacesDSLTest < Test::Unit::TestCase
     assert ns.respond_to?(:original_initialize_called)
   end
 
+  def test_namespace_should_accept_respond_to_with_include_priv_parameter
+    @config.namespace(:outer) {}
+    ns = @config.namespaces[:outer]
+    assert ns.respond_to?(:original_initialize_called, true)
+  end
+
   def test_namespace_should_delegate_unknown_messages_to_its_parent
     @config.namespace(:outer) {}
     ns = @config.namespaces[:outer]
@@ -280,4 +286,47 @@ class ConfigurationNamespacesDSLTest < Test::Unit::TestCase
     inner = @config.namespaces[:outer].namespaces[:inner]
     assert_nil inner.search_task(:first)
   end
-end
+
+  def test_top_should_return_self_if_self_is_top
+    assert_equal @config, @config.top
+  end
+
+  def test_top_should_return_parent_if_parent_is_top
+    @config.namespace(:outer) {}
+    assert_equal @config, @config.namespaces[:outer].top
+  end
+
+  def test_top_should_return_topmost_parent_if_self_is_deeply_nested
+    @config.namespace(:outer) { namespace(:middle) { namespace(:inner) {} } }
+    assert_equal @config, @config.namespaces[:outer].namespaces[:middle].namespaces[:inner].top
+  end
+
+  def test_find_task_should_return_nil_when_empty_inner_task
+    @config.namespace :outer do
+      namespace :inner do
+      end
+    end
+    assert_nil @config.find_task("outer::inner")
+  end
+
+  def test_kernel_method_clashing_should_not_affect_method_delegation_to_parent
+    @config.class.class_eval do
+      def some_weird_method() 'config' end
+    end
+
+    @config.namespace(:clash) {}
+    namespace = @config.namespaces[:clash]
+    assert_equal 'config', namespace.some_weird_method
+
+    Kernel.module_eval do
+      def some_weird_method() 'kernel' end
+    end
+
+    @config.namespace(:clash2) {}
+    namespace = @config.namespaces[:clash2]
+    assert_equal 'config', namespace.some_weird_method
+
+    Kernel.send :remove_method, :some_weird_method
+    @config.class.send :remove_method, :some_weird_method
+  end
+end

data/test/configuration/roles_test.rb

@@ -1,5 +1,6 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/roles'
+require 'capistrano/server_definition'
 
 class ConfigurationRolesTest < Test::Unit::TestCase
   class MockConfig
@@ -21,21 +22,56 @@ class ConfigurationRolesTest < Test::Unit::TestCase
     assert @config.roles.empty?
   end
 
+  def test_roles_for_host_with_one_role
+    @config.role :app, "app1.capistrano.test"
+    @config.role :not_app, "not-app.capistrano.test"
+    app_server = @config.roles[:app].servers.first
+    assert @config.role_names_for_host(app_server)==[ :app ]
+  end
+
+  def test_roles_for_host_with_multiple_roles
+    @config.server "www.capistrano.test", :db, :worker
+    db_server = @config.roles[:db].servers.first
+    assert_equal @config.role_names_for_host(db_server).map(&:to_s).sort, [ 'db', 'worker' ]
+  end
+
   def test_role_should_allow_empty_list
     @config.role :app
+    assert @config.roles.keys.include?(:app)
     assert @config.roles[:app].empty?
   end
 
   def test_role_with_one_argument_should_add_to_roles_collection
     @config.role :app, "app1.capistrano.test"
     assert_equal [:app], @config.roles.keys
-    assert_equal %w(app1.capistrano.test), @config.roles[:app].map { |s| s.host }
+    assert_role_equals %w(app1.capistrano.test)
+  end
+
+  def test_role_block_returning_single_string_is_added_to_roles_collection
+    @config.role :app do
+      'app1.capistrano.test'
+    end
+    assert_role_equals %w(app1.capistrano.test)
   end
 
   def test_role_with_multiple_arguments_should_add_each_to_roles_collection
     @config.role :app, "app1.capistrano.test", "app2.capistrano.test"
     assert_equal [:app], @config.roles.keys
-    assert_equal %w(app1.capistrano.test app2.capistrano.test), @config.roles[:app].map { |s| s.host }
+    assert_role_equals %w(app1.capistrano.test app2.capistrano.test)
+  end
+
+  def test_role_with_block_and_strings_should_add_both_to_roles_collection
+    @config.role :app, 'app1.capistrano.test' do
+      'app2.capistrano.test'
+    end
+    assert_role_equals %w(app1.capistrano.test app2.capistrano.test)
+  end
+
+  def test_role_block_returning_array_should_add_each_to_roles_collection
+    @config.role :app do
+      ['app1.capistrano.test', 'app2.capistrano.test']
+    end
+    assert_role_equals %w(app1.capistrano.test app2.capistrano.test)
   end
 
   def test_role_with_options_should_apply_options_to_each_argument
@@ -44,4 +80,78 @@ class ConfigurationRolesTest < Test::Unit::TestCase
       assert_equal({:extra => :value}, server.options)
     end
   end
-end
+
+  def test_role_with_options_should_apply_options_to_block_results
+    @config.role :app, :extra => :value do
+      ['app1.capistrano.test', 'app2.capistrano.test']
+    end
+    @config.roles[:app].each do |server|
+      assert_equal({:extra => :value}, server.options)
+    end
+  end
+
+  def test_options_should_apply_only_to_this_argument_set
+    @config.role :app, 'app1.capistrano.test', 'app2.capistrano.test' do
+      ['app3.capistrano.test', 'app4.capistrano.test']
+    end
+    @config.role :app, 'app5.capistrano.test', 'app6.capistrano.test', :extra => :value do
+      ['app7.capistrano.test', 'app8.capistrano.test']
+    end
+    @config.role :app, 'app9.capistrano.test'
+
+    option_hosts = ['app5.capistrano.test', 'app6.capistrano.test', 'app7.capistrano.test', 'app8.capistrano.test']
+    @config.roles[:app].each do |server|
+      if (option_hosts.include? server.host)
+        assert_equal({:extra => :value}, server.options)
+      else
+        assert_not_equal({:extra => :value}, server.options)
+      end
+    end
+  end
+
+  # Here, the source should be more readable than the method name
+  def test_role_block_returns_options_hash_is_merged_with_role_options_argument
+    @config.role :app, :first => :one, :second => :two do
+      ['app1.capistrano.test', 'app2.capistrano.test', {:second => :please, :third => :three}]
+    end
+    @config.roles[:app].each do |server|
+      assert_equal({:first => :one, :second => :please, :third => :three}, server.options)
+    end
+  end
+
+  def test_role_block_can_override_role_options_argument
+    @config.role :app, :value => :wrong do
+      Capistrano::ServerDefinition.new('app.capistrano.test')
+    end
+    @config.roles[:app].servers
+    @config.roles[:app].servers.each do |server|
+      assert_not_equal({:value => :wrong}, server.options)
+    end
+  end
+
+  def test_role_block_can_return_nil
+    @config.role :app do
+      nil
+    end
+    assert_role_equals ([])
+  end
+
+  def test_role_block_can_return_empty_array
+    @config.role :app do
+      []
+    end
+    assert_role_equals ([])
+  end
+
+  def test_role_definitions_via_server_should_associate_server_with_roles
+    @config.server "www.capistrano.test", :web, :app
+    assert_equal %w(www.capistrano.test), @config.roles[:app].map { |s| s.host }
+    assert_equal %w(www.capistrano.test), @config.roles[:web].map { |s| s.host }
+  end
+
+  private
+
+    def assert_role_equals(list)
+      assert_equal list, @config.roles[:app].map { |s| s.host }
+    end
+end