capistrano 2.4.3 → 2.5.0

data/test/configuration/actions/invocation_test.rb

@@ -5,6 +5,7 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
   class MockConfig
     attr_reader :options
     attr_accessor :debug
+    attr_accessor :dry_run
 
     def initialize
       @options = {}
@@ -40,20 +41,10 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
     @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"
-  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_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_add_default_command_options_should_return_bare_options_if_there_is_no_env_or_shell_specified
@@ -175,7 +166,7 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
     a = mock("channel", :called => true)
     b = mock("stream", :called => true)
     c = mock("data", :called => true)
-
+  
     callback[a, b, c]
   end
 
@@ -203,6 +194,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

data/test/configuration/connections_test.rb

@@ -58,18 +58,36 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
     assert_equal :session, @config.connection_factory.connect_to(server)
   end
 
-  def test_connection_factory_should_return_gateway_instance_if_gateway_variable_is_set
-    @config.values[:gateway] = "j@capistrano"
-    Net::SSH::Gateway.expects(:new).with("capistrano", "j", :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
+  def test_should_connect_through_gateway_if_gateway_variable_is_set
+    @config.values[:gateway] = "j@gateway"
+    Net::SSH::Gateway.expects(:new).with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
     assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
   end
 
   def test_connection_factory_as_gateway_should_honor_config_options
-    @config.values[:gateway] = "capistrano"
+    @config.values[:gateway] = "gateway"
     @config.values.update(@ssh_options)
-    Net::SSH::Gateway.expects(:new).with("capistrano", "user", :debug => :verbose, :port => 8080, :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
+    Net::SSH::Gateway.expects(:new).with("gateway", "user", :debug => :verbose, :port => 8080, :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
     assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
   end
+  
+  def test_connection_factory_as_gateway_should_chain_gateways_if_gateway_variable_is_an_array
+    @config.values[:gateway] = ["j@gateway1", "k@gateway2"]
+    gateway1 = mock
+    Net::SSH::Gateway.expects(:new).with("gateway1", "j", :password => nil, :auth_methods => %w(publickey hostbased)).returns(gateway1)
+    gateway1.expects(:open).returns(65535)
+    Net::SSH::Gateway.expects(:new).with("127.0.0.1", "k", :port => 65535, :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
+    assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
+  end
+  
+  def test_connection_factory_as_gateway_should_share_gateway_between_connections
+    @config.values[:gateway] = "j@gateway"
+    Net::SSH::Gateway.expects(:new).once.with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
+    Capistrano::SSH.stubs(:connect).returns(stub_everything)
+    assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
+    @config.establish_connections_to(server("capistrano"))
+    @config.establish_connections_to(server("another"))
+  end
 
   def test_establish_connections_to_should_accept_a_single_nonarray_parameter
     Capistrano::SSH.expects(:connect).with { |s,| s.host == "capistrano" }.returns(:success)
@@ -107,12 +125,13 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
       flunk "expected an exception to be raised"
     rescue Capistrano::ConnectionError => e
       assert e.respond_to?(:hosts)
-      assert_equal %w(cap1 cap2), e.hosts.map { |h| h.to_s }
+      assert_equal %w(cap1 cap2), e.hosts.map { |h| h.to_s }.sort
     end
   end
   
   def test_connection_error_should_only_include_failed_hosts
-    Capistrano::SSH.expects(:connect).times(2).raises(Exception).then.returns(:success)
+    Capistrano::SSH.expects(:connect).with(server('cap1'), anything).raises(Exception)
+    Capistrano::SSH.expects(:connect).with(server('cap2'), anything).returns(:success)
 
     begin
       @config.establish_connections_to(%w(cap1 cap2).map { |s| server(s) })
@@ -203,7 +222,8 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
   def test_execute_servers_should_not_raise_connection_error_on_failure_with_on_errors_continue
     @config.current_task = mock_task(:on_error => :continue)
     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1"), server("cap2")])
-    Capistrano::SSH.expects(:connect).times(2).raises(Exception).then.returns(:success)
+    Capistrano::SSH.expects(:connect).with(server('cap1'), anything).raises(Exception)
+    Capistrano::SSH.expects(:connect).with(server('cap2'), anything).returns(:success)
     assert_nothing_raised {
       @config.execute_on_servers do |servers|
         assert_equal %w(cap2), servers.map { |s| s.host }
@@ -215,7 +235,8 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
     list = [server("cap1"), server("cap2")]
     @config.current_task = mock_task(:on_error => :continue)
     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns(list)
-    Capistrano::SSH.expects(:connect).times(2).raises(Exception).then.returns(:success)
+    Capistrano::SSH.expects(:connect).with(server('cap1'), anything).raises(Exception)
+    Capistrano::SSH.expects(:connect).with(server('cap2'), anything).returns(:success)
     @config.execute_on_servers do |servers|
       assert_equal %w(cap2), servers.map { |s| s.host }
     end

data/test/configuration/execution_test.rb

@@ -116,6 +116,22 @@ class ConfigurationExecutionTest < Test::Unit::TestCase
     assert @config.state[:aaa]
   end
 
+  def test_on_rollback_called_twice_should_result_in_last_rollback_block_being_effective
+    aaa = new_task(@config, :aaa) do
+      transaction do
+        on_rollback { (state[:rollback] ||= []) << :first }
+        on_rollback { (state[:rollback] ||= []) << :second }
+        raise "boom"
+      end
+    end
+
+    assert_raises(RuntimeError) do
+      @config.execute_task(aaa)
+    end
+
+    assert_equal [:second], @config.state[:rollback]
+  end
+
   def test_find_and_execute_task_should_raise_error_when_task_cannot_be_found
     @config.expects(:find_task).with("path:to:task").returns(nil)
     assert_raises(Capistrano::NoSuchTaskError) { @config.find_and_execute_task("path:to:task") }

data/test/configuration/servers_test.rb

@@ -37,6 +37,13 @@ class ConfigurationServersTest < Test::Unit::TestCase
     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
@@ -63,6 +70,14 @@ class ConfigurationServersTest < Test::Unit::TestCase
     ENV['HOSTS'] = nil
   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['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 }

data/test/configuration_test.rb

@@ -12,7 +12,14 @@ class ConfigurationTest < Test::Unit::TestCase
 
   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)
-    Capistrano::Command.expects(:process).with("echo 'hello world'", [:session], :logger => @config.logger)
+
+    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"

data/test/deploy/local_dependency_test.rb

@@ -6,68 +6,71 @@ class LocalDependencyTest < Test::Unit::TestCase
     @config = { }
     @dependency = Capistrano::Deploy::LocalDependency.new(@config)
   end
-  
+
   def test_should_use_standard_error_message
     setup_for_one_path_entry(false)
     @dependency.command("cat")
     assert_equal "`cat' could not be found in the path on the local host", @dependency.message
   end
-  
+
   def test_should_use_alternative_message_if_provided
     setup_for_one_path_entry(false)
     @dependency.command("cat").or("Sorry")
     assert_equal "Sorry", @dependency.message
   end
-  
+
   def test_env_with_no_path_should_never_find_command
     ENV.expects(:[]).with("PATH").returns(nil)
     assert !@dependency.command("cat").pass?
   end
-  
+
   def test_env_with_one_path_entry_should_fail_if_command_not_found
     setup_for_one_path_entry(false)
     assert !@dependency.command("cat").pass?
   end
-  
+
   def test_env_with_one_path_entry_should_pass_if_command_found
     setup_for_one_path_entry(true)
     assert @dependency.command("cat").pass?
   end
-  
+
   def test_env_with_three_path_entries_should_fail_if_command_not_found
     setup_for_three_path_entries(false)
     assert !@dependency.command("cat").pass?
   end
-  
+
   def test_env_with_three_path_entries_should_pass_if_command_found
     setup_for_three_path_entries(true)
     assert @dependency.command("cat").pass?
   end
-  
+
   def test_env_with_one_path_entry_on_windows_should_pass_if_command_found_with_extension
     setup_for_one_path_entry_on_windows(true)
     assert @dependency.command("cat").pass?
   end
-  
+
   private
 
   def setup_for_one_path_entry(command_found)
+    Capistrano::Deploy::LocalDependency.expects(:on_windows?).returns(false)
     ENV.expects(:[]).with("PATH").returns("/bin")
     File.expects(:executable?).with("/bin/cat").returns(command_found)
   end
-  
+
   def setup_for_three_path_entries(command_found)
+    Capistrano::Deploy::LocalDependency.expects(:on_windows?).returns(false)
     path = %w(/bin /usr/bin /usr/local/bin).join(File::PATH_SEPARATOR)
     ENV.expects(:[]).with("PATH").returns(path)
     File.expects(:executable?).with("/usr/bin/cat").returns(command_found)
     File.expects(:executable?).at_most(1).with("/bin/cat").returns(false)
     File.expects(:executable?).at_most(1).with("/usr/local/bin/cat").returns(false)
   end
-  
+
   def setup_for_one_path_entry_on_windows(command_found)
     Capistrano::Deploy::LocalDependency.expects(:on_windows?).returns(true)
     ENV.expects(:[]).with("PATH").returns("/cygwin/bin")
     File.stubs(:executable?).returns(false)
-    File.expects(:executable?).with("/cygwin/bin/cat.exe").returns(command_found)
+    first_executable_extension = Capistrano::Deploy::LocalDependency.windows_executable_extensions.first
+    File.expects(:executable?).with("/cygwin/bin/cat#{first_executable_extension}").returns(command_found)
   end
 end

data/test/deploy/scm/none_test.rb

@@ -0,0 +1,35 @@
+require 'utils'
+require 'capistrano/recipes/deploy/scm/none'
+
+class DeploySCMNoneTest < Test::Unit::TestCase
+  class TestSCM < Capistrano::Deploy::SCM::None
+    default_command 'none'
+  end
+
+  def setup
+    @config = {}
+    def @config.exists?(name); key?(name); end
+    @source = TestSCM.new(@config)
+  end
+
+  def test_the_truth
+    assert true
+  end
+
+  def test_checkout_on_linux
+    Capistrano::Deploy::LocalDependency.stubs(:on_windows?).returns(false)
+    @config[:repository] = '.'
+    rev = ''
+    dest = '/var/www'
+    assert_equal "cp -R . /var/www", @source.checkout(rev, dest)
+  end
+
+  def test_checkout_on_windows
+    Capistrano::Deploy::LocalDependency.stubs(:on_windows?).returns(true)
+    @config[:repository] = '.'
+    rev = ''
+    dest = 'c:/Documents and settings/admin/tmp'
+    assert_equal "xcopy . \"c:/Documents and settings/admin/tmp\" /S/I/Y/Q/E", @source.checkout(rev, dest)
+  end
+
+end

data/test/deploy/strategy/copy_test.rb

@@ -29,6 +29,19 @@ class DeployStrategyCopyTest < Test::Unit::TestCase
     Dir.expects(:tmpdir).returns("/temp/dir")
     @source.expects(:checkout).with("154", "/temp/dir/1234567890").returns(:local_checkout)
     @strategy.expects(:system).with(:local_checkout)
+    Dir.expects(:glob).with("/temp/dir/1234567890/.git", File::FNM_DOTMATCH).returns("/temp/dir/1234567890/.git")
+
+    FileUtils.expects(:rm_rf).with("/temp/dir/1234567890/.git")
+    prepare_standard_compress_and_copy!
+    @strategy.deploy!
+  end
+
+  def test_deploy_with_exclusions_should_remove_glob_patterns_from_destination
+    @config[:copy_exclude] = ".gi*"
+    Dir.expects(:tmpdir).returns("/temp/dir")
+    @source.expects(:checkout).with("154", "/temp/dir/1234567890").returns(:local_checkout)
+    @strategy.expects(:system).with(:local_checkout)
+    Dir.expects(:glob).with("/temp/dir/1234567890/.gi*", File::FNM_DOTMATCH).returns("/temp/dir/1234567890/.git")
 
     FileUtils.expects(:rm_rf).with("/temp/dir/1234567890/.git")
     prepare_standard_compress_and_copy!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: capistrano
 version: !ruby/object:Gem::Version 
-  version: 2.4.3
+  version: 2.5.0
 platform: ruby
 authors: 
 - Jamis Buck
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-28 00:00:00 -06:00
+date: 2008-08-28 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -293,6 +293,7 @@ test_files:
 - test/deploy/scm/base_test.rb
 - test/deploy/scm/git_test.rb
 - test/deploy/scm/mercurial_test.rb
+- test/deploy/scm/none_test.rb
 - test/deploy/strategy/copy_test.rb
 - test/extensions_test.rb
 - test/logger_test.rb