capistrano 1.4.2 → 2.0.0

data/test/configuration/namespace_dsl_test.rb

@@ -0,0 +1,283 @@
+require "#{File.dirname(__FILE__)}/../utils"
+require 'capistrano/configuration/namespaces'
+
+class ConfigurationNamespacesDSLTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :original_initialize_called, :options
+
+    def initialize
+      @original_initialize_called = true
+      @options = {}
+    end
+
+    include Capistrano::Configuration::Namespaces
+  end
+
+  def setup
+    @config = MockConfig.new
+  end
+
+  def test_initialize_should_initialize_collections
+    assert @config.original_initialize_called
+    assert @config.tasks.empty?
+    assert @config.namespaces.empty?
+  end
+
+  def test_unqualified_task_should_define_task_at_top_namespace
+    assert !@config.tasks.key?(:testing)
+    @config.task(:testing) { puts "something" }
+    assert @config.tasks.key?(:testing)
+  end
+
+  def test_qualification_should_define_task_within_namespace
+    @config.namespace(:testing) do
+      task(:nested) { puts "nested" }
+    end
+
+    assert !@config.tasks.key?(:nested)
+    assert @config.namespaces.key?(:testing)
+    assert @config.namespaces[:testing].tasks.key?(:nested)
+  end
+
+  def test_namespace_within_namespace_should_define_task_within_nested_namespace
+    @config.namespace :outer do
+      namespace :inner do
+        task :nested do
+          puts "nested"
+        end
+      end
+    end
+
+    assert !@config.tasks.key?(:nested)
+    assert @config.namespaces.key?(:outer)
+    assert @config.namespaces[:outer].namespaces.key?(:inner)
+    assert @config.namespaces[:outer].namespaces[:inner].tasks.key?(:nested)
+  end
+
+  def test_pending_desc_should_apply_only_to_immediately_subsequent_task
+    @config.desc "A description"
+    @config.task(:testing) { puts "foo" }
+    @config.task(:another) { puts "bar" }
+    assert_equal "A description", @config.tasks[:testing].desc
+    assert_nil @config.tasks[:another].desc
+  end
+
+  def test_pending_desc_should_apply_only_to_next_task_in_any_namespace
+    @config.desc "A description"
+    @config.namespace(:outer) { task(:testing) { puts "foo" } }
+    assert_equal "A description", @config.namespaces[:outer].tasks[:testing].desc
+  end
+
+  def test_defining_task_without_block_should_raise_error
+    assert_raises(ArgumentError) do
+      @config.task(:testing)
+    end
+  end
+
+  def test_defining_task_that_shadows_existing_method_should_raise_error
+    assert_raises(ArgumentError) do
+      @config.task(:sprintf) { puts "foo" }
+    end
+  end
+
+  def test_defining_task_that_shadows_existing_namespace_should_raise_error
+    @config.namespace(:outer) {}
+    assert_raises(ArgumentError) do
+      @config.task(:outer) { puts "foo" }
+    end
+  end
+
+  def test_defining_namespace_that_shadows_existing_method_should_raise_error
+    assert_raises(ArgumentError) do
+      @config.namespace(:sprintf) {}
+    end
+  end
+
+  def test_defining_namespace_that_shadows_existing_task_should_raise_error
+    @config.task(:testing) { puts "foo" }
+    assert_raises(ArgumentError) do
+      @config.namespace(:testing) {}
+    end
+  end
+
+  def test_defining_task_that_shadows_existing_task_should_not_raise_error
+    @config.task(:original) { puts "foo" }
+    assert_nothing_raised do
+      @config.task(:original) { puts "bar" }
+    end
+  end
+
+  def test_defining_ask_should_add_task_as_method
+    assert !@config.methods.include?("original")
+    @config.task(:original) { puts "foo" }
+    assert @config.methods.include?("original")
+  end
+
+  def test_calling_defined_task_should_delegate_to_execute_task
+    @config.task(:original) { puts "foo" }
+    @config.expects(:execute_task).with(@config.tasks[:original])
+    @config.original
+  end
+
+  def test_role_inside_namespace_should_raise_error
+    assert_raises(NotImplementedError) do
+      @config.namespace(:outer) do
+        role :app, "hello"
+      end
+    end
+  end
+
+  def test_name_for_top_level_should_be_nil
+    assert_nil @config.name
+  end
+
+  def test_parent_for_top_level_should_be_nil
+    assert_nil @config.parent
+  end
+
+  def test_fqn_for_top_level_should_be_nil
+    assert_nil @config.fully_qualified_name
+  end
+
+  def test_fqn_for_namespace_should_be_the_name_of_the_namespace
+    @config.namespace(:outer) {}
+    assert_equal "outer", @config.namespaces[:outer].fully_qualified_name
+  end
+
+  def test_parent_for_namespace_should_be_the_top_level
+    @config.namespace(:outer) {}
+    assert_equal @config, @config.namespaces[:outer].parent    
+  end
+
+  def test_fqn_for_nested_namespace_should_be_color_delimited
+    @config.namespace(:outer) { namespace(:inner) {} }
+    assert_equal "outer:inner", @config.namespaces[:outer].namespaces[:inner].fully_qualified_name
+  end
+
+  def test_parent_for_nested_namespace_should_be_the_nesting_namespace
+    @config.namespace(:outer) { namespace(:inner) {} }
+    assert_equal @config.namespaces[:outer], @config.namespaces[:outer].namespaces[:inner].parent
+  end
+
+  def test_find_task_should_dereference_nested_tasks
+    @config.namespace(:outer) do
+      namespace(:inner) { task(:nested) { puts "nested" } }
+    end
+
+    task = @config.find_task("outer:inner:nested")
+    assert_not_nil task
+    assert_equal "outer:inner:nested", task.fully_qualified_name
+  end
+
+  def test_find_task_should_return_nil_if_no_task_matches
+    assert_nil @config.find_task("outer:inner:nested")
+  end
+
+  def test_find_task_should_return_default_if_deferences_to_namespace_and_namespace_has_default
+    @config.namespace(:outer) do
+      namespace(:inner) { task(:default) { puts "nested" } }
+    end
+
+    task = @config.find_task("outer:inner")
+    assert_not_nil task
+    assert_equal :default, task.name
+    assert_equal "outer:inner", task.namespace.fully_qualified_name
+  end
+
+  def test_find_task_should_return_nil_if_deferences_to_namespace_and_namespace_has_no_default
+    @config.namespace(:outer) do
+      namespace(:inner) { task(:nested) { puts "nested" } }
+    end
+
+    assert_nil @config.find_task("outer:inner")
+  end
+
+  def test_default_task_should_return_nil_for_top_level
+    @config.task(:default) {}
+    assert_nil @config.default_task
+  end
+
+  def test_default_task_should_return_nil_for_namespace_without_default
+    @config.namespace(:outer) { task(:nested) { puts "nested" } }
+    assert_nil @config.namespaces[:outer].default_task
+  end
+
+  def test_default_task_should_return_task_for_namespace_with_default
+    @config.namespace(:outer) { task(:default) { puts "nested" } }
+    task = @config.namespaces[:outer].default_task
+    assert_not_nil task
+    assert_equal :default, task.name
+  end
+
+  def test_task_list_should_return_only_tasks_immediately_within_namespace
+    @config.task(:first) { puts "here" }
+    @config.namespace(:outer) do
+      task(:second) { puts "here" }
+      namespace(:inner) do
+        task(:third) { puts "here" }
+      end
+    end
+
+    assert_equal %w(first), @config.task_list.map { |t| t.fully_qualified_name }
+  end
+
+  def test_task_list_with_all_should_return_all_tasks_under_this_namespace_recursively
+    @config.task(:first) { puts "here" }
+    @config.namespace(:outer) do
+      task(:second) { puts "here" }
+      namespace(:inner) do
+        task(:third) { puts "here" }
+      end
+    end
+
+    assert_equal %w(first outer:inner:third outer:second), @config.task_list(:all).map { |t| t.fully_qualified_name }.sort
+  end
+
+  def test_namespace_should_respond_to_its_parents_methods
+    @config.namespace(:outer) {}
+    ns = @config.namespaces[:outer]
+    assert ns.respond_to?(:original_initialize_called)
+  end
+
+  def test_namespace_should_delegate_unknown_messages_to_its_parent
+    @config.namespace(:outer) {}
+    ns = @config.namespaces[:outer]
+    assert ns.original_initialize_called
+  end
+
+  def test_namespace_should_not_understand_messages_that_neither_it_nor_its_parent_understands
+    @config.namespace(:outer) {}
+    ns = @config.namespaces[:outer]
+    assert_raises(NoMethodError) { ns.alskdfjlsf }
+  end
+
+  def test_search_task_should_find_tasks_in_current_namespace
+    @config.namespace(:outer) do
+      namespace(:inner) do
+        task(:third) { puts "here" }
+      end
+    end
+
+    inner = @config.namespaces[:outer].namespaces[:inner]
+    assert_equal inner.tasks[:third], inner.search_task(:third)
+  end
+
+  def test_search_task_should_find_tasks_in_parent_namespace
+    @config.task(:first) { puts "here" }
+    @config.namespace(:outer) do
+      task(:second) { puts "here" }
+      namespace(:inner) do
+        task(:third) { puts "here" }
+      end
+    end
+
+    inner = @config.namespaces[:outer].namespaces[:inner]
+    assert_equal @config.tasks[:first], inner.search_task(:first)
+  end
+
+  def test_search_task_should_return_nil_if_no_tasks_are_found
+    @config.namespace(:outer) { namespace(:inner) {} }
+    inner = @config.namespaces[:outer].namespaces[:inner]
+    assert_nil inner.search_task(:first)
+  end
+end

data/test/configuration/roles_test.rb

@@ -0,0 +1,47 @@
+require "#{File.dirname(__FILE__)}/../utils"
+require 'capistrano/configuration/roles'
+
+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_role_should_allow_empty_list
+    @config.role :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 }
+  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 }
+  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
+end

data/test/configuration/servers_test.rb

@@ -0,0 +1,90 @@
+require "#{File.dirname(__FILE__)}/../utils"
+require 'capistrano/task_definition'
+require 'capistrano/configuration/servers'
+
+class ConfigurationServersTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :roles
+
+    def initialize
+      @roles = {}
+    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
+
+  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['ROLES'] = nil
+  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['HOSTS'] = nil
+  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
+end

data/test/configuration/variables_test.rb

@@ -0,0 +1,180 @@
+require "#{File.dirname(__FILE__)}/../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_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