capistrano 2.0.0 → 2.15.9

data/test/configuration/actions/invocation_test.rb

@@ -1,12 +1,19 @@
-require "#{File.dirname(__FILE__)}/../../utils"
+require "utils"
 require 'capistrano/configuration/actions/invocation'
+require 'capistrano/configuration/actions/file_transfer'
 
 class ConfigurationActionsInvocationTest < Test::Unit::TestCase
   class MockConfig
     attr_reader :options
+    attr_accessor :debug
+    attr_accessor :dry_run
+    attr_accessor :preserve_roles
+    attr_accessor :servers
+    attr_accessor :roles
 
     def initialize
       @options = {}
+      @servers = []
     end
 
     def [](*args)
@@ -21,13 +28,21 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
       @options.fetch(*args)
     end
 
+    def filter_servers(options = {})
+      [nil, @servers]
+    end
+
+    def execute_on_servers(options = {})
+      yield @servers
+    end
+
     include Capistrano::Configuration::Actions::Invocation
+    include Capistrano::Configuration::Actions::FileTransfer
   end
 
   def setup
-    @config = MockConfig.new
+    @config = make_config
     @original_io_proc = MockConfig.default_io_proc
-    @config.stubs(:logger).returns(stub_everything)
   end
 
   def teardown
@@ -35,24 +50,23 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
   end
 
   def test_run_options_should_be_passed_to_execute_on_servers
-    @config.expects(:execute_on_servers).with(:foo => "bar")
+    @config.expects(:execute_on_servers).with(:foo => "bar", :eof => true)
     @config.run "ls", :foo => "bar"
   end
 
-  def test_run_without_block_should_use_default_io_proc
-    @config.expects(:execute_on_servers).yields(%w(s1 s2 s3).map { |s| server(s) })
-    @config.expects(:sessions).returns(Hash.new { |h,k| h[k] = k.host.to_sym }).times(3)
-    prepare_command("ls", [:s1, :s2, :s3], {:logger => @config.logger})
-    MockConfig.default_io_proc = inspectable_proc
-    @config.run "ls"
+  def test_run_will_return_if_dry_run
+    @config.expects(:dry_run).returns(true)
+    @config.expects(:execute_on_servers).never
+    @config.run "ls", :foo => "bar"
   end
 
-  def test_run_with_block_should_use_block
-    @config.expects(:execute_on_servers).yields(%w(s1 s2 s3).map { |s| mock(:host => s) })
-    @config.expects(:sessions).returns(Hash.new { |h,k| h[k] = k.host.to_sym }).times(3)
-    prepare_command("ls", [:s1, :s2, :s3], {:logger => @config.logger})
-    MockConfig.default_io_proc = Proc.new { |a,b,c| raise "shouldn't get here" }
-    @config.run("ls", &inspectable_proc)
+  def test_put_wont_transfer_if_dry_run
+    config = make_config
+    config.dry_run = true
+    config.servers = %w[ foo ]
+    config.expects(:execute_on_servers).never
+    ::Capistrano::Transfer.expects(:process).never
+    config.put "foo", "bar", :mode => 0644
   end
 
   def test_add_default_command_options_should_return_bare_options_if_there_is_no_env_or_shell_specified
@@ -75,6 +89,11 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
     assert_equal({:foo => "bar", :shell => "/bin/bash"}, @config.add_default_command_options(:foo => "bar"))
   end
 
+  def test_add_default_command_options_should_use_default_shell_of_false_if_present
+    @config.set :default_shell, false
+    assert_equal({:foo => "bar", :shell => false}, @config.add_default_command_options(:foo => "bar"))
+  end
+
   def test_add_default_command_options_should_use_shell_in_preference_of_default_shell
     @config.set :default_shell, "/bin/bash"
     assert_equal({:foo => "bar", :shell => "/bin/sh"}, @config.add_default_command_options(:foo => "bar", :shell => "/bin/sh"))
@@ -97,38 +116,56 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
   end
 
   def test_sudo_should_default_to_sudo
-    @config.expects(:run).with("sudo ls", {})
+    @config.expects(:run).with("sudo -p 'sudo password: ' ls", {})
     @config.sudo "ls"
   end
 
+  def test_sudo_should_keep_input_stream_open
+    @config.expects(:execute_on_servers).with(:foo => "bar")
+    @config.sudo "ls", :foo => "bar"
+  end
+
   def test_sudo_should_use_sudo_variable_definition
-    @config.expects(:run).with("/opt/local/bin/sudo ls", {})
+    @config.expects(:run).with("/opt/local/bin/sudo -p 'sudo password: ' ls", {})
     @config.options[:sudo] = "/opt/local/bin/sudo"
     @config.sudo "ls"
   end
 
   def test_sudo_should_interpret_as_option_as_user
-    @config.expects(:run).with("sudo -u app ls", {})
+    @config.expects(:run).with("sudo -p 'sudo password: ' -u app ls", {})
     @config.sudo "ls", :as => "app"
   end
 
   def test_sudo_should_pass_options_through_to_run
-    @config.expects(:run).with("sudo ls", :foo => "bar")
+    @config.expects(:run).with("sudo -p 'sudo password: ' ls", :foo => "bar")
     @config.sudo "ls", :foo => "bar"
   end
 
-  def test_sudo_behavior_callback_should_send_password_when_prompted
+  def test_sudo_should_avoid_minus_p_when_sudo_prompt_is_empty
+    @config.set :sudo_prompt, ""
+    @config.expects(:run).with("sudo ls", {})
+    @config.sudo "ls"
+  end
+
+  def test_sudo_should_interpret_sudo_prompt_variable_as_custom_prompt
+    @config.set :sudo_prompt, "give it to me: "
+    @config.expects(:run).with("sudo -p 'give it to me: ' ls", {})
+    @config.sudo "ls"
+  end
+
+  def test_sudo_behavior_callback_should_send_password_when_prompted_with_default_sudo_prompt
     ch = mock("channel")
     ch.expects(:send_data).with("g00b3r\n")
     @config.options[:password] = "g00b3r"
-    @config.sudo_behavior_callback(nil)[ch, nil, "Password: "]
+    @config.sudo_behavior_callback(nil)[ch, nil, "sudo password: "]
   end
 
-  def test_sudo_behavior_callback_should_send_password_when_prompted_with_SuSE_dialect
+  def test_sudo_behavior_callback_should_send_password_when_prompted_with_custom_sudo_prompt
     ch = mock("channel")
     ch.expects(:send_data).with("g00b3r\n")
+    @config.set :sudo_prompt, "give it to me: "
     @config.options[:password] = "g00b3r"
-    @config.sudo_behavior_callback(nil)[ch, nil, "user's password: "]
+    @config.sudo_behavior_callback(nil)[ch, nil, "give it to me: "]
   end
 
   def test_sudo_behavior_callback_with_incorrect_password_on_first_prompt
@@ -136,7 +173,7 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
     ch.stubs(:[]).with(:host).returns("capistrano")
     ch.stubs(:[]).with(:server).returns(server("capistrano"))
     @config.expects(:reset!).with(:password)
-    @config.sudo_behavior_callback(nil)[ch, nil, "blah blah try again blah blah"]
+    @config.sudo_behavior_callback(nil)[ch, nil, "Sorry, try again."]
   end
 
   def test_sudo_behavior_callback_with_incorrect_password_on_subsequent_prompts
@@ -151,9 +188,23 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
 
     @config.expects(:reset!).with(:password).times(2)
 
-    callback[ch, nil, "blah blah try again blah blah"]
-    callback[ch2, nil, "blah blah try again blah blah"] # shouldn't call reset!
-    callback[ch, nil, "blah blah try again blah blah"]
+    callback[ch, nil, "Sorry, try again."]
+    callback[ch2, nil, "Sorry, try again."] # shouldn't call reset!
+    callback[ch, nil, "Sorry, try again."]
+  end
+
+  def test_sudo_behavior_callback_should_reset_password_and_prompt_again_if_output_includes_both_cues
+    ch = mock("channel")
+    ch.stubs(:[]).with(:host).returns("capistrano")
+    ch.stubs(:[]).with(:server).returns(server("capistrano"))
+    ch.expects(:send_data, "password!\n").times(2)
+
+    @config.set(:password, "password!")
+    @config.expects(:reset!).with(:password)
+
+    callback = @config.sudo_behavior_callback(nil)
+    callback[ch, :out, "sudo password: "]
+    callback[ch, :out, "Sorry, try again.\nsudo password: "]
   end
 
   def test_sudo_behavior_callback_should_defer_to_fallback_for_other_output
@@ -176,8 +227,63 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
     @config.invoke_command("ls", :once => true, :via => :foobar)
   end
 
+  def test_parallel_command_execution_with_no_match
+    assert_block("should not raise argument error") do
+      begin
+        @config.parallel do |session|
+          session.when("in?(:app)", "ls") {|ch,stream,data| puts "noop"}
+          session.when("in?(:db)", "pwd") {|ch,stream,data| puts "noop"}
+        end
+        true
+      rescue
+        false
+      end
+    end
+  end
+
+  def test_parallel_command_execution_with_matching_servers
+    @config.expects(:execute_on_servers)
+
+    logger = mock('logger')
+    logger.stubs(:debug).with("executing multiple commands in parallel").once
+    logger.stubs(:trace).twice
+    @config.stubs(:logger).returns(logger)
+
+    assert_block("should not raise Argument error") do
+      begin
+        @config.servers = [:app, :db]
+        @config.roles = {:app => [:app], :db => [:db] }
+        @config.parallel do |session|
+          session.when("in?(:app)", "ls") {|ch,stream,data| puts "noop"}
+          session.when("in?(:db)", "pwd") {|ch,stream,data| puts "noop"}
+        end
+        true
+      rescue
+        false
+      end
+    end
+  end
+
+  def test_run_only_logs_once
+    @config.servers = [:app, :db]
+
+    logger = mock('logger')
+    logger.stubs(:debug).with("executing \"ls\"")
+    @config.stubs(:logger).returns(logger)
+
+    @config.expects(:execute_on_servers)
+
+    @config.run("ls")
+  end
+
   private
 
+    def make_config
+      config = MockConfig.new
+      config.stubs(:logger).returns(stub_everything)
+      config
+    end
+
     def inspectable_proc
       Proc.new do |ch, stream, data|
         ch.called
@@ -190,6 +296,11 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
       a = mock("channel", :called => true)
       b = mock("stream", :called => true)
       c = mock("data", :called => true)
-      Capistrano::Command.expects(:process).with(command, sessions, options).yields(a, b, c)
+
+      compare_args = Proc.new do |tree, sess, opts|
+        tree.fallback.command == command && sess == sessions && opts == options
+      end
+
+      Capistrano::Command.expects(:process).with(&compare_args)
     end
-end
+end

data/test/configuration/alias_task_test.rb

@@ -0,0 +1,118 @@
+require 'utils'
+require 'capistrano/configuration/alias_task'
+require 'capistrano/configuration/execution'
+require 'capistrano/configuration/namespaces'
+require 'capistrano/task_definition'
+
+class AliasTaskTest < Test::Unit::TestCase
+  class MockConfig
+    attr_reader :options
+    attr_accessor :logger
+
+    def initialize(options={})
+      @options = {}
+      @logger = options.delete(:logger)
+    end
+
+    include Capistrano::Configuration::AliasTask
+    include Capistrano::Configuration::Execution
+    include Capistrano::Configuration::Namespaces
+  end
+
+  def setup
+    @config = MockConfig.new( :logger => stub(:debug => nil, :info => nil, :important => nil) )
+  end
+
+  def test_makes_a_copy_of_the_task
+    @config.task(:foo) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    assert @config.tasks.key?(:new_foo)
+  end
+
+  def test_original_task_remain_with_same_name
+    @config.task(:foo) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    assert_equal :foo, @config.tasks[:foo].name
+    assert_equal :new_foo, @config.tasks[:new_foo].name
+  end
+
+  def test_aliased_task_do_the_same
+    @config.task(:foo) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    assert_equal 42, @config.find_and_execute_task('new_foo')
+  end
+
+  def test_aliased_task_should_preserve_description
+    @config.task(:foo, :desc => "the Ultimate Question of Life, the Universe, and Everything" ) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    task = @config.find_task('foo')
+    new_task = @config.find_task('new_foo')
+
+    assert_equal task.description, new_task.description
+  end
+
+  def test_aliased_task_should_preserve_on_error
+    @config.task(:foo, :on_error => :continue) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    task = @config.find_task('foo')
+    new_task = @config.find_task('new_foo')
+
+    assert_equal task.on_error, new_task.on_error
+  end
+
+  def test_aliased_task_should_preserve_max_hosts
+    @config.task(:foo, :max_hosts => 5) { 42 }
+    @config.alias_task 'new_foo', 'foo'
+
+    task = @config.find_task('foo')
+    new_task = @config.find_task('new_foo')
+
+    assert_equal task.max_hosts, new_task.max_hosts
+  end
+
+  def test_raise_exception_when_task_doesnt_exist
+    assert_raises(Capistrano::NoSuchTaskError) { @config.alias_task 'non_existant_task', 'fail_miserably' }
+  end
+
+  def test_convert_task_names_using_to_str
+    @config.task(:foo, :role => :app) { 42 }
+
+    @config.alias_task 'one', 'foo'
+    @config.alias_task :two, 'foo'
+    @config.alias_task 'three', :foo
+    @config.alias_task :four, :foo
+
+    assert @config.tasks.key?(:one)
+    assert @config.tasks.key?(:two)
+    assert @config.tasks.key?(:three)
+    assert @config.tasks.key?(:four)
+  end
+
+  def test_raise_an_exception_when_task_names_can_not_be_converted
+    @config.task(:foo, :role => :app) { 42 }
+
+    assert_raises(ArgumentError) { @config.alias_task mock('x'), :foo }
+  end
+
+  def test_should_include_namespace
+    @config.namespace(:outer) do
+      task(:foo) { 42 }
+      alias_task 'new_foo', 'foo'
+
+      namespace(:inner) do
+        task(:foo) { 43 }
+        alias_task 'new_foo', 'foo'
+      end
+    end
+
+    assert_equal 42, @config.find_and_execute_task('outer:new_foo')
+    assert_equal 42, @config.find_and_execute_task('outer:foo')
+    assert_equal 43, @config.find_and_execute_task('outer:inner:new_foo')
+    assert_equal 43, @config.find_and_execute_task('outer:inner:foo')
+  end
+end

data/test/configuration/callbacks_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/callbacks'
 
 class ConfigurationCallbacksTest < Test::Unit::TestCase
@@ -12,9 +12,15 @@ class ConfigurationCallbacksTest < Test::Unit::TestCase
     end
 
     def execute_task(task)
-      @called << task
+      invoke_task_directly(task)
     end
 
+    protected
+
+      def invoke_task_directly(task)
+        @called << task
+      end
+
     include Capistrano::Configuration::Callbacks
   end
 
@@ -33,11 +39,35 @@ class ConfigurationCallbacksTest < Test::Unit::TestCase
     @config.before :bar, :foo, "bing:blang", :zip => :zing
   end
 
+  def test_before_should_map_before_deploy_symlink
+    @config.before "deploy:symlink", "bing:blang", "deploy:symlink"
+    assert_equal "bing:blang", @config.callbacks[:before][0].source
+    assert_equal "deploy:create_symlink", @config.callbacks[:before][1].source
+    assert_equal ["deploy:create_symlink"], @config.callbacks[:before][1].only
+  end
+
+  def test_before_should_map_before_deploy_symlink_array
+    @config.before ["deploy:symlink", "bingo:blast"], "bing:blang"
+    assert_equal ["deploy:create_symlink", "bingo:blast"], @config.callbacks[:before].last.only
+  end
+
   def test_after_should_delegate_to_on
     @config.expects(:on).with(:after, :foo, "bing:blang", {:only => :bar, :zip => :zing})
     @config.after :bar, :foo, "bing:blang", :zip => :zing
   end
 
+  def test_after_should_map_before_deploy_symlink
+    @config.after "deploy:symlink", "bing:blang", "deploy:symlink"
+    assert_equal "bing:blang", @config.callbacks[:after][0].source
+    assert_equal "deploy:create_symlink", @config.callbacks[:after][1].source
+    assert_equal ["deploy:create_symlink"], @config.callbacks[:after][1].only
+  end
+
+  def test_after_should_map_before_deploy_symlink_array
+    @config.after ["deploy:symlink", "bingo:blast"], "bing:blang"
+    assert_equal ["deploy:create_symlink", "bingo:blast"], @config.callbacks[:after].last.only
+  end
+
   def test_on_with_single_reference_should_add_task_callback
     @config.on :before, :a_test
     assert_equal 1, @config.callbacks[:before].length
@@ -97,6 +127,14 @@ class ConfigurationCallbacksTest < Test::Unit::TestCase
     assert_equal %w(primary), @config.callbacks[:before].first.except
   end
 
+  def test_on_without_tasks_or_block_should_raise_error
+    assert_raises(ArgumentError) { @config.on(:before) }
+  end
+
+  def test_on_with_both_tasks_and_block_should_raise_error
+    assert_raises(ArgumentError) { @config.on(:before, :first) { blah } }
+  end
+
   def test_trigger_without_constraints_should_invoke_all_callbacks
     task = stub(:fully_qualified_name => "any:old:thing")
     @config.on(:before, :first, "second:third")
@@ -160,47 +198,4 @@ class ConfigurationCallbacksTest < Test::Unit::TestCase
     assert_equal [task], @config.called
   end
 
-  def test_execute_task_with_named_before_hook_should_call_named_before_hook
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-    before_task = stub(:fully_qualified_name => "any:old:before_thing", :name => "before_thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-    ns.expects(:search_task).with("before_thing").returns(before_task)
-
-    @config.execute_task(task)
-    assert_equal [before_task, task], @config.called
-  end
-
-  def test_execute_task_with_named_after_hook_should_call_named_after_hook
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-    after_task = stub(:fully_qualified_name => "any:old:after_thing", :name => "after_thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-    ns.expects(:search_task).with("after_thing").returns(after_task)
-
-    @config.execute_task(task)
-    assert_equal [task, after_task], @config.called
-  end
-
-  def test_execute_task_with_on_hooks_should_trigger_hooks_around_task
-    ns = stub("namespace", :default_task => nil, :name => "old", :fully_qualified_name => "any:old")
-    task = stub(:fully_qualified_name => "any:old:thing", :name => "thing", :namespace => ns)
-    before_task = stub(:fully_qualified_name => "any:old:before_thing", :name => "before_thing", :namespace => ns)
-    after_task = stub(:fully_qualified_name => "any:old:after_thing", :name => "after_thing", :namespace => ns)
-
-    ns.stubs(:search_task).returns(nil)
-    ns.expects(:search_task).with("before_thing").returns(before_task)
-    ns.expects(:search_task).with("after_thing").returns(after_task)
-
-    @config.before("any:old:thing", :first_this, :then_this)
-    @config.after("any:old:thing", :and_then_this, :lastly_this)
-
-    [:first_this, :then_this, :and_then_this, :lastly_this].each do |t|
-      @config.expects(:find_and_execute_task).with(t)
-    end
-
-    @config.execute_task(task)
-  end
-end
+end