minmb-capistrano 2.15.4

data/test/configuration/roles_test.rb

@@ -0,0 +1,157 @@
+require "utils"
+require 'capistrano/configuration/roles'
+require 'capistrano/server_definition'
+
+class ConfigurationRolesTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :original_initialize_called
+
+    def initialize
+      @original_initialize_called = true
+    end
+
+    include Capistrano::Configuration::Roles
+  end
+
+  def setup
+    @config = MockConfig.new
+  end
+
+  def test_initialize_should_initialize_roles_collection
+    assert @config.original_initialize_called
+    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_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_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
+    @config.role :app, "app1.capistrano.test", "app2.capistrano.test", :extra => :value
+    @config.roles[:app].each do |server|
+      assert_equal({:extra => :value}, server.options)
+    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

data/test/configuration/servers_test.rb

@@ -0,0 +1,183 @@
+require "utils"
+require 'capistrano/task_definition'
+require 'capistrano/configuration/servers'
+
+class ConfigurationServersTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :roles
+    attr_accessor :preserve_roles
+
+    def initialize
+      @roles = {}
+      @preserve_roles = false
+    end
+
+    include Capistrano::Configuration::Servers
+  end
+
+  def setup
+    @config = MockConfig.new
+    role(@config, :app, "app1", :primary => true)
+    role(@config, :app, "app2", "app3")
+    role(@config, :web, "web1", "web2")
+    role(@config, :report, "app2", :no_deploy => true)
+    role(@config, :file, "file", :no_deploy => true)
+  end
+
+  def test_task_without_roles_should_apply_to_all_defined_hosts
+    task = new_task(:testing)
+    assert_equal %w(app1 app2 app3 web1 web2 file).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  end
+
+  def test_task_with_explicit_role_list_should_apply_only_to_those_roles
+    task = new_task(:testing, @config, :roles => %w(app web))
+    assert_equal %w(app1 app2 app3 web1 web2).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  end
+
+  def test_task_with_single_role_should_apply_only_to_that_role
+    task = new_task(:testing, @config, :roles => :web)
+    assert_equal %w(web1 web2).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  end
+
+  # NOTE Rather than throw an error, as it used to, we return an
+  #  empty array so that if a task is okay with a missing role it can continue on
+  def test_task_with_unknown_role_should_return_empty_array
+    task = new_task(:testing, @config, :roles => :bogus)
+    assert_equal [], @config.find_servers_for_task(task)
+  end
+
+  def test_task_with_hosts_option_should_apply_only_to_those_hosts
+    task = new_task(:testing, @config, :hosts => %w(foo bar))
+    assert_equal %w(foo bar).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  end
+
+  def test_task_with_single_hosts_option_should_apply_only_to_that_host
+    task = new_task(:testing, @config, :hosts => "foo")
+    assert_equal %w(foo).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  end
+
+  def test_task_with_roles_as_environment_variable_should_apply_only_to_that_role
+    ENV['ROLES'] = "app,file"
+    task = new_task(:testing)
+    assert_equal %w(app1 app2 app3 file).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('ROLES')
+  end
+
+  def test_task_with_roles_as_environment_variable_and_preserve_roles_should_apply_only_to_existant_task_role
+    ENV['ROLES'] = "app,file"
+    @config.preserve_roles = true
+    task = new_task(:testing,@config, :roles => :app)
+    assert_equal %w(app1 app2 app3).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('ROLES')
+  end
+
+  def test_task_with_roles_as_environment_variable_and_preserve_roles_should_apply_only_to_existant_task_roles
+    ENV['ROLES'] = "app,file,web"
+    @config.preserve_roles = true
+    task = new_task(:testing,@config, :roles => [ :app,:file ])
+    assert_equal %w(app1 app2 app3 file).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('ROLES')
+  end
+
+  def test_task_with_roles_as_environment_variable_and_preserve_roles_should_not_apply_if_not_exists_those_task_roles
+    ENV['ROLES'] = "file,web"
+    @config.preserve_roles = true
+    task = new_task(:testing,@config, :roles => [ :app ])
+    assert_equal [], @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('ROLES')
+  end
+  
+  def test_task_with_hosts_as_environment_variable_should_apply_only_to_those_hosts
+    ENV['HOSTS'] = "foo,bar"
+    task = new_task(:testing)
+    assert_equal %w(foo bar).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('HOSTS')
+  end
+
+  def test_task_with_hosts_as_environment_variable_should_not_inspect_roles_at_all
+    ENV['HOSTS'] = "foo,bar"
+    task = new_task(:testing, @config, :roles => :bogus)
+    assert_equal %w(foo bar).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('HOSTS')
+  end
+
+  def test_task_with_hostfilter_environment_variable_should_apply_only_to_those_hosts
+    ENV['HOSTFILTER'] = "app1,web1"
+    task = new_task(:testing)
+    assert_equal %w(app1 web1).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('HOSTFILTER')
+  end
+
+  def test_task_with_hostfilter_environment_variable_should_filter_hosts_option
+    ENV['HOSTFILTER'] = "foo"
+    task = new_task(:testing, @config, :hosts => %w(foo bar))
+    assert_equal %w(foo).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('HOSTFILTER')
+  end
+
+  def test_task_with_hostfilter_environment_variable_and_skip_hostfilter_should_not_filter_hosts_option
+    ENV['HOSTFILTER'] = "foo"
+    task = new_task(:testing, @config, :hosts => %w(foo bar), :skip_hostfilter => true)
+    assert_equal %w(foo bar).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('HOSTFILTER')
+  end
+
+  def test_task_with_hostrolefilter_environment_variable_should_apply_only_to_those_hosts
+    ENV['HOSTROLEFILTER'] = "web"
+    task = new_task(:testing)
+    assert_equal %w(web1 web2).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('HOSTROLEFILTER')
+  end
+
+  def test_task_with_only_should_apply_only_to_matching_tasks
+    task = new_task(:testing, @config, :roles => :app, :only => { :primary => true })
+    assert_equal %w(app1), @config.find_servers_for_task(task).map { |s| s.host }
+  end
+
+  def test_task_with_except_should_apply_only_to_matching_tasks
+    task = new_task(:testing, @config, :except => { :no_deploy => true })
+    assert_equal %w(app1 app2 app3 web1 web2).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  end
+
+  def test_options_to_find_servers_for_task_should_override_options_in_task
+    task = new_task(:testing, @config, :roles => :web)
+    assert_equal %w(app1 app2 app3).sort, @config.find_servers_for_task(task, :roles => :app).map { |s| s.host }.sort
+  end
+
+  def test_find_servers_with_lambda_for_hosts_should_be_evaluated
+    assert_equal %w(foo), @config.find_servers(:hosts => lambda { "foo" }).map { |s| s.host }.sort
+    assert_equal %w(bar foo), @config.find_servers(:hosts => lambda { %w(foo bar) }).map { |s| s.host }.sort
+  end
+
+  def test_find_servers_with_lambda_for_roles_should_be_evaluated
+    assert_equal %w(app1 app2 app3), @config.find_servers(:roles => lambda { :app }).map { |s| s.host }.sort
+    assert_equal %w(app2 file), @config.find_servers(:roles => lambda { [:report, :file] }).map { |s| s.host }.sort
+  end
+
+  def test_find_servers_with_hosts_nil_or_empty
+    assert_equal [], @config.find_servers(:hosts => nil)
+    assert_equal [], @config.find_servers(:hosts => [])
+    result = @config.find_servers(:hosts => @config.find_servers(:roles => :report)[0])
+    assert_equal 1, result.size
+    result = @config.find_servers(:hosts => "app1")
+    assert_equal 1, result.size
+  end
+
+  def test_find_servers_with_rolees_nil_or_empty
+    assert_equal [], @config.find_servers(:roles => nil)
+    assert_equal [], @config.find_servers(:roles => [])
+    result = @config.find_servers(:roles => :report)
+    assert_equal 1, result.size
+  end
+
+end

data/test/configuration/variables_test.rb

@@ -0,0 +1,190 @@
+require "utils"
+require 'capistrano/configuration/variables'
+
+class ConfigurationVariablesTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :original_initialize_called
+
+    def initialize
+      @original_initialize_called = true
+    end
+
+    include Capistrano::Configuration::Variables
+  end
+
+  def setup
+    MockConfig.any_instance.stubs(:logger).returns(stub_everything)
+    @config = MockConfig.new
+  end
+
+  def test_initialize_should_initialize_variables_hash
+    assert @config.original_initialize_called
+    assert_equal({:ssh_options => {}, :logger => @config.logger}, @config.variables)
+  end
+
+  def test_set_should_add_variable_to_hash
+    @config.set :sample, :value
+    assert_equal :value, @config.variables[:sample]
+  end
+
+  def test_set_should_convert_variable_name_to_symbol
+    @config.set "sample", :value
+    assert_equal :value, @config.variables[:sample]
+  end
+
+  def test_set_should_be_aliased_to_square_brackets
+    @config[:sample] = :value
+    assert_equal :value, @config.variables[:sample]
+  end
+
+  def test_variables_should_be_accessible_as_read_accessors
+    @config[:sample] = :value
+    assert_equal :value, @config.sample
+  end
+
+  def test_method_missing_should_raise_error_if_no_variable_matches
+    assert_raises(NoMethodError) do
+      @config.sample
+    end
+  end
+
+  def test_respond_to_should_look_for_variables
+    assert !@config.respond_to?(:sample)
+    @config[:sample] = :value
+    assert @config.respond_to?(:sample)
+  end
+
+  def test_respond_to_should_be_true_when_passed_a_string
+    assert !@config.respond_to?('sample')
+    @config[:sample] = :value
+    assert @config.respond_to?('sample')
+  end
+
+  def test_respond_to_with_include_priv_paramter
+    assert !@config.respond_to?(:sample, true)
+  end
+
+  def test_set_should_require_value
+    assert_raises(ArgumentError) do
+      @config.set(:sample)
+    end
+  end
+
+  def test_set_should_allow_value_to_be_omitted_if_block_is_given
+    assert_nothing_raised do
+      @config.set(:sample) { :value }
+    end
+    assert_instance_of Proc, @config.variables[:sample]
+  end
+
+  def test_set_should_not_allow_multiple_values
+    assert_raises(ArgumentError) do
+      @config.set(:sample, :value, :another)
+    end
+  end
+
+  def test_set_should_not_allow_both_a_value_and_a_block
+    assert_raises(ArgumentError) do
+      @config.set(:sample, :value) { :block }
+    end
+  end
+
+  def test_set_should_not_allow_capitalized_variables
+    assert_raises(ArgumentError) do
+      @config.set :Sample, :value
+    end
+  end
+
+  def test_unset_should_remove_variable_from_hash
+    @config.set :sample, :value
+    assert @config.variables.key?(:sample)
+    @config.unset :sample
+    assert !@config.variables.key?(:sample)
+  end
+
+  def test_unset_should_clear_memory_of_original_proc
+    @config.set(:sample) { :value }
+    @config.fetch(:sample)
+    @config.unset(:sample)
+    assert_equal false, @config.reset!(:sample)
+  end
+
+  def test_exists_should_report_existance_of_variable_in_hash
+    assert !@config.exists?(:sample)
+    @config[:sample] = :value
+    assert @config.exists?(:sample)
+  end
+
+  def test_reset_should_do_nothing_if_variable_does_not_exist
+    assert_equal false, @config.reset!(:sample)
+    assert !@config.variables.key?(:sample)
+  end
+
+  def test_reset_should_do_nothing_if_variable_is_not_a_proc
+    @config.set(:sample, :value)
+    assert_equal false, @config.reset!(:sample)
+    assert_equal :value, @config.variables[:sample]
+  end
+
+  def test_reset_should_do_nothing_if_proc_variable_has_not_been_dereferenced
+    @config.set(:sample) { :value }
+    assert_equal false, @config.reset!(:sample)
+    assert_instance_of Proc, @config.variables[:sample]
+  end
+
+  def test_reset_should_restore_variable_to_original_proc_value
+    @config.set(:sample) { :value }
+    assert_instance_of Proc, @config.variables[:sample]
+    @config.fetch(:sample)
+    assert_instance_of Symbol, @config.variables[:sample]
+    assert @config.reset!(:sample)
+    assert_instance_of Proc, @config.variables[:sample]
+  end
+
+  def test_fetch_should_return_stored_non_proc_value
+    @config.set(:sample, :value)
+    assert_equal :value, @config.fetch(:sample)
+  end
+
+  def test_fetch_should_raise_index_error_if_variable_does_not_exist
+    assert_raises(IndexError) do
+      @config.fetch(:sample)
+    end
+  end
+
+  def test_fetch_should_return_default_if_variable_does_not_exist_and_default_is_given
+    assert_nothing_raised do
+      assert_equal :default_value, @config.fetch(:sample, :default_value)
+    end
+  end
+
+  def test_fetch_should_invoke_block_if_variable_does_not_exist_and_block_is_given
+    assert_nothing_raised do
+      assert_equal :default_value, @config.fetch(:sample) { :default_value }
+    end
+  end
+
+  def test_fetch_should_raise_argument_error_if_both_default_and_block_are_given
+    assert_raises(ArgumentError) do
+      @config.fetch(:sample, :default1) { :default2 }
+    end
+  end
+
+  def test_fetch_should_dereference_proc_values
+    @config.set(:sample) { :value }
+    assert_instance_of Proc, @config.variables[:sample]
+    assert_equal :value, @config.fetch(:sample)
+    assert_instance_of Symbol, @config.variables[:sample]
+  end
+
+  def test_square_brackets_should_alias_fetch
+    @config.set(:sample, :value)
+    assert_equal :value, @config[:sample]
+  end
+
+  def test_square_brackets_should_return_nil_for_non_existant_variable
+    assert_nothing_raised do
+      assert_nil @config[:sample]
+    end
+  end
+end