capistrano 2.8.0 → 3.19.0

data/test/configuration/loading_test.rb

@@ -1,132 +0,0 @@
-require 'utils'
-require 'capistrano/configuration/loading'
-
-class ConfigurationLoadingTest < Test::Unit::TestCase
-  class MockConfig
-    attr_accessor :ping
-    attr_reader :original_initialize_called
-
-    def initialize
-      @original_initialize_called = true
-    end
-
-    def ping!(value)
-      @ping = value
-    end
-
-    include Capistrano::Configuration::Loading
-  end
-
-  def setup
-    @config = MockConfig.new
-  end
-
-  def teardown
-    MockConfig.instance = nil
-    $LOADED_FEATURES.delete_if { |a| a =~ /fixtures\/custom\.rb$/ }
-  end
-
-  def test_initialize_should_init_collections
-    assert @config.original_initialize_called
-    assert @config.load_paths.include?(".")
-    assert @config.load_paths.detect { |v| v =~ /capistrano\/recipes$/ }
-  end
-
-  def test_load_with_options_and_block_should_raise_argument_error
-    assert_raises(ArgumentError) do
-      @config.load(:string => "foo") { something }
-    end
-  end
-
-  def test_load_with_arguments_and_block_should_raise_argument_error
-    assert_raises(ArgumentError) do
-      @config.load("foo") { something }
-    end
-  end
-
-  def test_load_from_string_should_eval_in_config_scope
-    @config.load :string => "ping! :here"
-    assert_equal :here, @config.ping
-  end
-
-  def test_load_from_file_shoudld_respect_load_path
-    File.stubs(:file?).returns(false)
-    File.stubs(:file?).with("custom/path/for/file.rb").returns(true)
-    File.stubs(:read).with("custom/path/for/file.rb").returns("ping! :here")
-
-    @config.load_paths << "custom/path/for"
-    @config.load :file => "file.rb"
-
-    assert_equal :here, @config.ping
-  end
-
-  def test_load_from_file_should_respect_load_path_and_appends_rb
-    File.stubs(:file?).returns(false)
-    File.stubs(:file?).with("custom/path/for/file.rb").returns(true)
-    File.stubs(:read).with("custom/path/for/file.rb").returns("ping! :here")
-
-    @config.load_paths << "custom/path/for"
-    @config.load :file => "file"
-
-    assert_equal :here, @config.ping
-  end
-
-  def test_load_from_file_should_raise_load_error_if_file_cannot_be_found
-    File.stubs(:file?).returns(false)
-    assert_raises(LoadError) do
-      @config.load :file => "file"
-    end
-  end
-
-  def test_load_from_proc_should_eval_proc_in_config_scope
-    @config.load :proc => Proc.new { ping! :here }
-    assert_equal :here, @config.ping
-  end
-
-  def test_load_with_block_should_treat_block_as_proc_parameter
-    @config.load { ping! :here }
-    assert_equal :here, @config.ping
-  end
-
-  def test_load_with_unrecognized_option_should_raise_argument_error
-    assert_raises(ArgumentError) do
-      @config.load :url => "http://www.load-this.test"
-    end
-  end
-
-  def test_load_with_arguments_should_treat_arguments_as_files
-    File.stubs(:file?).returns(false)
-    File.stubs(:file?).with("./first.rb").returns(true)
-    File.stubs(:file?).with("./second.rb").returns(true)
-    File.stubs(:read).with("./first.rb").returns("ping! 'this'")
-    File.stubs(:read).with("./second.rb").returns("ping << 'that'")
-    assert_nothing_raised { @config.load "first", "second" }
-    assert_equal "thisthat", @config.ping
-  end
-
-  def test_require_from_config_should_load_file_in_config_scope
-    assert_nothing_raised do
-      @config.require "#{File.expand_path(File.dirname(__FILE__))}/../fixtures/custom"
-    end
-    assert_equal :custom, @config.ping
-  end
-
-  def test_require_without_config_should_raise_load_error
-    assert_raises(LoadError) do
-      require "#{File.dirname(__FILE__)}/../fixtures/custom"
-    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,311 +0,0 @@
-require "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.any? { |m| m.to_sym == :original }
-    @config.task(:original) { puts "foo" }
-    assert @config.methods.any? { |m| m.to_sym == :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_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]
-    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
-
-  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
-end

data/test/configuration/roles_test.rb

@@ -1,144 +0,0 @@
-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_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