minmb-capistrano 2.15.4

data/test/configuration_test.rb

@@ -0,0 +1,77 @@
+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, :eof => true }
+    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
+
+end

data/test/deploy/local_dependency_test.rb

@@ -0,0 +1,76 @@
+require "utils"
+require 'capistrano/recipes/deploy/local_dependency'
+
+class LocalDependencyTest < Test::Unit::TestCase
+  def setup
+    @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)
+    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/remote_dependency_test.rb

@@ -0,0 +1,146 @@
+require "utils"
+require 'capistrano/recipes/deploy/remote_dependency'
+
+class RemoteDependencyTest < Test::Unit::TestCase
+  def setup
+    @config = { }
+    @dependency = Capistrano::Deploy::RemoteDependency.new(@config)
+  end
+
+  def test_should_use_standard_error_message_for_directory
+    setup_for_a_configuration_run("test -d /data", false)
+    @dependency.directory("/data")
+    assert_equal "`/data' is not a directory (host)", @dependency.message
+  end
+
+  def test_should_use_standard_error_message_for_file
+    setup_for_a_configuration_run("test -f /data/foo.txt", false)
+    @dependency.file("/data/foo.txt")
+    assert_equal "`/data/foo.txt' is not a file (host)", @dependency.message
+  end
+
+  def test_should_use_standard_error_message_for_writable
+    setup_for_a_configuration_run("test -w /data/foo.txt", false)
+    @dependency.writable("/data/foo.txt")
+    assert_equal "`/data/foo.txt' is not writable (host)", @dependency.message
+  end
+
+  def test_should_use_standard_error_message_for_command
+    setup_for_a_configuration_run("which cat", false)
+    @dependency.command("cat")
+    assert_equal "`cat' could not be found in the path (host)", @dependency.message
+  end
+
+  def test_should_use_standard_error_message_for_gem
+    setup_for_a_configuration_gem_run("capistrano", "9.9", false)
+    @dependency.gem("capistrano", 9.9)
+    assert_equal "gem `capistrano' 9.9 could not be found (host)", @dependency.message
+  end
+
+  def test_should_use_standard_error_message_for_deb
+    setup_for_a_configuration_deb_run("dpkg", "1.15", false)
+    @dependency.deb("dpkg", "1.15")
+    assert_equal "package `dpkg' 1.15 could not be found (host)", @dependency.message
+  end
+
+  def test_should_use_standard_error_message_for_rpm
+    setup_for_a_configuration_rpm_run("rpm", "4.8", false)
+    @dependency.rpm("rpm", "4.8")
+    assert_equal "package `rpm' 4.8 could not be found (host)", @dependency.message
+  end
+
+  def test_should_fail_if_directory_not_found
+    setup_for_a_configuration_run("test -d /data", false)
+    assert !@dependency.directory("/data").pass?
+  end
+
+  def test_should_pass_if_directory_found
+    setup_for_a_configuration_run("test -d /data", true)
+    assert @dependency.directory("/data").pass?
+  end
+
+  def test_should_fail_if_file_not_found
+    setup_for_a_configuration_run("test -f /data/foo.txt", false)
+    assert !@dependency.file("/data/foo.txt").pass?
+  end
+
+  def test_should_pass_if_file_found
+    setup_for_a_configuration_run("test -f /data/foo.txt", true)
+    assert @dependency.file("/data/foo.txt").pass?
+  end
+
+  def test_should_fail_if_writable_not_found
+    setup_for_a_configuration_run("test -w /data/foo.txt", false)
+    assert !@dependency.writable("/data/foo.txt").pass?
+  end
+
+  def test_should_pass_if_writable_found
+    setup_for_a_configuration_run("test -w /data/foo.txt", true)
+    assert @dependency.writable("/data/foo.txt").pass?
+  end
+
+  def test_should_fail_if_command_not_found
+    setup_for_a_configuration_run("which cat", false)
+    assert !@dependency.command("cat").pass?
+  end
+
+  def test_should_pass_if_command_found
+    setup_for_a_configuration_run("which cat", true)
+    assert @dependency.command("cat").pass?
+  end
+
+  def test_should_fail_if_gem_not_found
+    setup_for_a_configuration_gem_run("capistrano", "9.9", false)
+    assert !@dependency.gem("capistrano", 9.9).pass?
+  end
+
+  def test_should_pass_if_gem_found
+    setup_for_a_configuration_gem_run("capistrano", "9.9", true)
+    assert @dependency.gem("capistrano", 9.9).pass?
+  end
+
+  def test_should_pass_if_deb_found
+    setup_for_a_configuration_deb_run("dpkg", "1.15", true)
+    assert @dependency.deb("dpkg", "1.15").pass?
+  end
+
+  def test_should_fail_if_deb_not_found
+    setup_for_a_configuration_deb_run("dpkg", "1.15", false)
+    assert !@dependency.deb("dpkg", "1.15").pass?
+  end
+
+  def test_should_use_alternative_message_if_provided
+    setup_for_a_configuration_run("which cat", false)
+    @dependency.command("cat").or("Sorry")
+    assert_equal "Sorry (host)", @dependency.message
+  end
+
+  private
+
+  def setup_for_a_configuration_run(command, passing)
+    expectation = @config.expects(:invoke_command).with(command, {})
+    if passing
+      expectation.returns(true)
+    else
+      error = Capistrano::CommandError.new
+      error.expects(:hosts).returns(["host"])
+      expectation.raises(error)
+    end
+  end
+
+  def setup_for_a_configuration_gem_run(name, version, passing)
+    @config.expects(:fetch).with(:gem_command, "gem").returns("gem")
+    find_gem_cmd = "gem specification --version '#{version}' #{name} 2>&1 | awk 'BEGIN { s = 0 } /^name:/ { s = 1; exit }; END { if(s == 0) exit 1 }'"
+    setup_for_a_configuration_run(find_gem_cmd, passing)
+  end
+
+  def setup_for_a_configuration_deb_run(name, version, passing)
+    find_deb_cmd = "dpkg -s #{name} | grep '^Version: #{version}'"
+    setup_for_a_configuration_run(find_deb_cmd, passing)
+  end
+
+  def setup_for_a_configuration_rpm_run(name, version, passing)
+    find_rpm_cmd = "rpm -q #{name} | grep '#{version}'"
+    setup_for_a_configuration_run(find_rpm_cmd, passing)
+  end
+end

data/test/deploy/scm/accurev_test.rb

@@ -0,0 +1,23 @@
+require "utils"
+require 'capistrano/recipes/deploy/scm/accurev'
+
+class AccurevTest < Test::Unit::TestCase
+  include Capistrano::Deploy::SCM
+
+  def test_internal_revision_to_s
+    assert_equal 'foo/1', Accurev::InternalRevision.new('foo', 1).to_s
+    assert_equal 'foo/highest', Accurev::InternalRevision.new('foo', 'highest').to_s
+  end
+
+  def test_internal_revision_parse
+    revision = Accurev::InternalRevision.parse('foo')
+    assert_equal 'foo', revision.stream
+    assert_equal 'highest', revision.transaction_id
+    assert_equal 'foo/highest', revision.to_s
+
+    revision = Accurev::InternalRevision.parse('foo/1')
+    assert_equal 'foo', revision.stream
+    assert_equal '1', revision.transaction_id
+    assert_equal 'foo/1', revision.to_s
+  end
+end

data/test/deploy/scm/base_test.rb

@@ -0,0 +1,55 @@
+require "utils"
+require 'capistrano/recipes/deploy/scm/base'
+
+class DeploySCMBaseTest < Test::Unit::TestCase
+  class TestSCM < Capistrano::Deploy::SCM::Base
+    default_command "floopy"
+  end
+
+  def setup
+    @config = { }
+    def @config.exists?(name); key?(name); end
+
+    @source = TestSCM.new(@config)
+  end
+
+  def test_command_should_default_to_default_command
+    assert_equal "floopy", @source.command
+    @source.local { assert_equal "floopy", @source.command }
+  end
+
+  def test_command_should_use_scm_command_if_available
+    @config[:scm_command] = "/opt/local/bin/floopy"
+    assert_equal "/opt/local/bin/floopy", @source.command
+  end
+
+  def test_command_should_use_scm_command_in_local_mode_if_local_scm_command_not_set
+    @config[:scm_command] = "/opt/local/bin/floopy"
+    @source.local { assert_equal "/opt/local/bin/floopy", @source.command }
+  end
+
+  def test_command_should_use_local_scm_command_in_local_mode_if_local_scm_command_is_set
+    @config[:scm_command] = "/opt/local/bin/floopy"
+    @config[:local_scm_command] = "/usr/local/bin/floopy"
+    assert_equal "/opt/local/bin/floopy", @source.command
+    @source.local { assert_equal "/usr/local/bin/floopy", @source.command }
+  end
+
+  def test_command_should_use_default_if_scm_command_is_default
+    @config[:scm_command] = :default
+    assert_equal "floopy", @source.command
+  end
+
+  def test_command_should_use_default_in_local_mode_if_local_scm_command_is_default
+    @config[:scm_command] = "/foo/bar/floopy"
+    @config[:local_scm_command] = :default
+    @source.local { assert_equal "floopy", @source.command }
+  end
+
+  def test_local_mode_proxy_should_treat_messages_as_being_in_local_mode
+    @config[:scm_command] = "/foo/bar/floopy"
+    @config[:local_scm_command] = :default
+    assert_equal "floopy", @source.local.command
+    assert_equal "/foo/bar/floopy", @source.command
+  end
+end

data/test/deploy/scm/bzr_test.rb

@@ -0,0 +1,51 @@
+require "utils"
+require 'capistrano/recipes/deploy/scm/bzr'
+
+class DeploySCMBzrTest < Test::Unit::TestCase
+  class TestSCM < Capistrano::Deploy::SCM::Bzr
+    default_command "bzr"
+  end
+
+  def setup
+    @config = { :repository => "." }
+
+    def @config.exists?(name); key?(name); end # is this actually needed?
+
+    @source = TestSCM.new(@config)
+  end
+
+  # The bzr scm does not support pseudo-ids. The bzr adapter uses symbol :head
+  # to refer to the recently committed revision.
+  def test_head_revision
+    assert_equal(:head,
+                 @source.head,
+                 "Since bzr doesn't know a real head revision, symbol :head is used instead.")
+  end
+
+  # The bzr scm does support many different ways to specify a revision. Only
+  # symbol :head triggers the bzr command 'revno'.
+  def test_query_revision
+    assert_equal("bzr revno #{@config[:repository]}",
+                 @source.query_revision(:head) { |o| o },
+                 "Query for :head revision should call bzr command 'revno' in repository directory.")
+
+    # Many valid revision specifications, some invalid on the last line
+    revision_samples = [ 5, -7, '2', '-4',
+                         'revid:revid:aaaa@bbbb-123456789',
+                         'submit:',
+                         'ancestor:/path/to/branch',
+                         'date:yesterday',
+                         'branch:/path/to/branch',
+                         'tag:trunk',
+                         'revno:3:/path/to/branch',
+                         'before:revid:aaaa@bbbb-1234567890',
+                         'last:3',
+                         nil, {}, [], true, false, 1.34, ]
+
+    revision_samples.each do |revivsion_spec|
+      assert_equal(revivsion_spec,
+                   @source.query_revision(revivsion_spec),
+                   "Any revision specification other than symbol :head should simply by returned.")
+    end
+  end
+end

data/test/deploy/scm/darcs_test.rb

@@ -0,0 +1,37 @@
+require "utils"
+require 'capistrano/recipes/deploy/scm/darcs'
+
+class DeploySCMDarcsTest < Test::Unit::TestCase
+  class TestSCM < Capistrano::Deploy::SCM::Darcs
+    default_command "darcs"
+  end
+  def setup
+    @config = { :repository => "." }
+  #  def @config.exists?(name); key?(name); end
+
+    @source = TestSCM.new(@config)
+  end
+
+  # We should be able to pick a specific hash.
+  def test_checkout_hash
+    hsh = "*version_hash*"
+    assert_match(%r{--to-match=.hash #{Regexp.quote(hsh)}},
+                 @source.checkout(hsh, "*foo_location*"),
+                "Specifying a revision hash got the --to-match option wrong.")
+  end
+
+  # Picking the head revision should leave out the hash, because head is the
+  # default and we don't have a HEAD pseudotag
+  def test_checkout_head
+    hsh = @source.head
+    assert_no_match(%r{--to-match}, @source.checkout(hsh, "*foo_location*"),
+                    "Selecting the head revision incorrectly produced a --to-match option.")
+  end
+
+  # Leaving the revision as nil shouldn't break anything.
+  def test_checkout_nil
+    assert_no_match(%r{--to-match}, @source.checkout(nil, "*foo_location*"),
+                    "Leaving the revision as nil incorrectly produced a --to-match option.")
+  end
+end
+