fotonauts-capistrano 2.5.2

data/test/configuration/roles_test.rb

@@ -0,0 +1,143 @@
+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[: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,121 @@
+require "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_unknown_role_should_raise_exception
+    task = new_task(:testing, @config, :roles => :bogus)
+    assert_raises(ArgumentError) do
+      @config.find_servers_for_task(task)
+    end
+  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_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_onlyhosts_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_onlyhosts_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_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 "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

data/test/configuration_test.rb

@@ -0,0 +1,88 @@
+require "utils"
+require 'capistrano/configuration'
+
+# These tests are only for testing the integration of the various components
+# of the Configuration class. To test specific features, please look at the
+# tests under test/configuration.
+
+class ConfigurationTest < Test::Unit::TestCase
+  def setup
+    @config = Capistrano::Configuration.new
+  end
+
+  def test_connections_execution_loading_namespaces_roles_and_variables_modules_should_integrate_correctly
+    Capistrano::SSH.expects(:connect).with { |s,c| s.host == "www.capistrano.test" && c == @config }.returns(:session)
+
+    process_args = Proc.new do |tree, session, opts|
+      tree.fallback.command == "echo 'hello world'" &&
+      session == [:session] &&
+      opts == { :logger => @config.logger }
+    end
+
+    Capistrano::Command.expects(:process).with(&process_args)
+
+    @config.load do
+      role :test, "www.capistrano.test"
+      set  :message, "hello world"
+      namespace :testing do
+        task :example, :roles => :test do
+          run "echo '#{message}'"
+        end
+      end
+    end
+
+    @config.testing.example
+  end
+
+  def test_tasks_in_nested_namespace_should_be_able_to_call_tasks_in_same_namespace
+    @config.namespace(:outer) do
+      task(:first) { set :called_first, true }
+      namespace(:inner) do
+        task(:first) { set :called_inner_first, true }
+        task(:second) { first }
+      end
+    end
+
+    @config.outer.inner.second
+    assert !@config[:called_first]
+    assert @config[:called_inner_first]
+  end
+
+  def test_tasks_in_nested_namespace_should_be_able_to_call_tasks_in_parent_namespace
+    @config.namespace(:outer) do
+      task(:first) { set :called_first, true }
+      namespace(:inner) do
+        task(:second) { first }
+      end
+    end
+
+    @config.outer.inner.second
+    assert @config[:called_first]
+  end
+
+  def test_tasks_in_nested_namespace_should_be_able_to_call_shadowed_tasks_in_parent_namespace
+    @config.namespace(:outer) do
+      task(:first) { set :called_first, true }
+      namespace(:inner) do
+        task(:first) { set :called_inner_first, true }
+        task(:second) { parent.first }
+      end
+    end
+
+    @config.outer.inner.second
+    assert @config[:called_first]
+    assert !@config[:called_inner_first]
+  end
+
+  def test_hooks_for_default_task_should_be_found_if_named_after_the_namespace
+    @config.namespace(:outer) do
+      task(:default) { set :called_default, true }
+      task(:before_outer) { set :called_before_outer, true }
+      task(:after_outer) { set :called_after_outer, true }
+    end
+    @config.outer.default
+    assert @config[:called_before_outer]
+    assert @config[:called_default]
+    assert @config[:called_after_outer]
+  end
+end