capistrano 2.0.0 → 2.15.5

data/test/configuration/roles_test.rb

@@ -1,5 +1,6 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/roles'
+require 'capistrano/server_definition'
 
 class ConfigurationRolesTest < Test::Unit::TestCase
   class MockConfig
@@ -21,21 +22,56 @@ class ConfigurationRolesTest < Test::Unit::TestCase
     assert @config.roles.empty?
   end
 
+  def test_roles_for_host_with_one_role
+    @config.role :app, "app1.capistrano.test"
+    @config.role :not_app, "not-app.capistrano.test"
+    app_server = @config.roles[:app].servers.first
+    assert @config.role_names_for_host(app_server)==[ :app ]
+  end
+
+  def test_roles_for_host_with_multiple_roles
+    @config.server "www.capistrano.test", :db, :worker
+    db_server = @config.roles[:db].servers.first
+    assert_equal @config.role_names_for_host(db_server).map(&:to_s).sort, [ 'db', 'worker' ]
+  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_equal %w(app1.capistrano.test), @config.roles[:app].map { |s| s.host }
+    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_equal %w(app1.capistrano.test app2.capistrano.test), @config.roles[:app].map { |s| s.host }
+    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
@@ -44,4 +80,78 @@ class ConfigurationRolesTest < Test::Unit::TestCase
       assert_equal({:extra => :value}, server.options)
     end
   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

@@ -1,13 +1,15 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/task_definition'
 require 'capistrano/configuration/servers'
 
 class ConfigurationServersTest < Test::Unit::TestCase
   class MockConfig
     attr_reader :roles
+    attr_accessor :preserve_roles
 
     def initialize
       @roles = {}
+      @preserve_roles = false
     end
 
     include Capistrano::Configuration::Servers
@@ -37,6 +39,13 @@ class ConfigurationServersTest < Test::Unit::TestCase
     assert_equal %w(web1 web2).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
   end
 
+  # NOTE Rather than throw an error, as it used to, we return an
+  #  empty array so that if a task is okay with a missing role it can continue on
+  def test_task_with_unknown_role_should_return_empty_array
+    task = new_task(:testing, @config, :roles => :bogus)
+    assert_equal [], @config.find_servers_for_task(task)
+  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
@@ -52,15 +61,82 @@ class ConfigurationServersTest < Test::Unit::TestCase
     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['ROLES'] = nil
+    ENV.delete('ROLES')
+  end
+
+  def test_task_with_roles_as_environment_variable_and_preserve_roles_should_apply_only_to_existant_task_role
+    ENV['ROLES'] = "app,file"
+    @config.preserve_roles = true
+    task = new_task(:testing,@config, :roles => :app)
+    assert_equal %w(app1 app2 app3).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('ROLES')
+  end
+
+  def test_task_with_roles_as_environment_variable_and_preserve_roles_should_apply_only_to_existant_task_roles
+    ENV['ROLES'] = "app,file,web"
+    @config.preserve_roles = true
+    task = new_task(:testing,@config, :roles => [ :app,:file ])
+    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_roles_as_environment_variable_and_preserve_roles_should_not_apply_if_not_exists_those_task_roles
+    ENV['ROLES'] = "file,web"
+    @config.preserve_roles = true
+    task = new_task(:testing,@config, :roles => [ :app ])
+    assert_equal [], @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['HOSTS'] = nil
+    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_hostfilter_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_hostfilter_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_hostfilter_environment_variable_and_skip_hostfilter_should_not_filter_hosts_option
+    ENV['HOSTFILTER'] = "foo"
+    task = new_task(:testing, @config, :hosts => %w(foo bar), :skip_hostfilter => true)
+    assert_equal %w(foo bar).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('HOSTFILTER')
+  end
+
+  def test_task_with_hostrolefilter_environment_variable_should_apply_only_to_those_hosts
+    ENV['HOSTROLEFILTER'] = "web"
+    task = new_task(:testing)
+    assert_equal %w(web1 web2).sort, @config.find_servers_for_task(task).map { |s| s.host }.sort
+  ensure
+    ENV.delete('HOSTROLEFILTER')
   end
 
   def test_task_with_only_should_apply_only_to_matching_tasks
@@ -87,4 +163,21 @@ class ConfigurationServersTest < Test::Unit::TestCase
     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
+
+  def test_find_servers_with_hosts_nil_or_empty
+    assert_equal [], @config.find_servers(:hosts => nil)
+    assert_equal [], @config.find_servers(:hosts => [])
+    result = @config.find_servers(:hosts => @config.find_servers(:roles => :report)[0])
+    assert_equal 1, result.size
+    result = @config.find_servers(:hosts => "app1")
+    assert_equal 1, result.size
+  end
+
+  def test_find_servers_with_rolees_nil_or_empty
+    assert_equal [], @config.find_servers(:roles => nil)
+    assert_equal [], @config.find_servers(:roles => [])
+    result = @config.find_servers(:roles => :report)
+    assert_equal 1, result.size
+  end
+
+end

data/test/configuration/variables_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/variables'
 
 class ConfigurationVariablesTest < Test::Unit::TestCase
@@ -54,6 +54,16 @@ class ConfigurationVariablesTest < Test::Unit::TestCase
     assert @config.respond_to?(:sample)
   end
 
+  def test_respond_to_should_be_true_when_passed_a_string
+    assert !@config.respond_to?('sample')
+    @config[:sample] = :value
+    assert @config.respond_to?('sample')
+  end
+
+  def test_respond_to_with_include_priv_paramter
+    assert !@config.respond_to?(:sample, true)
+  end
+
   def test_set_should_require_value
     assert_raises(ArgumentError) do
       @config.set(:sample)
@@ -177,4 +187,4 @@ class ConfigurationVariablesTest < Test::Unit::TestCase
       assert_nil @config[:sample]
     end
   end
-end
+end

data/test/configuration_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/utils"
+require "utils"
 require 'capistrano/configuration'
 
 # These tests are only for testing the integration of the various components
@@ -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, :eof => true }
+    end
+
+    Capistrano::Command.expects(:process).with(&process_args)
 
     @config.load do
       role :test, "www.capistrano.test"
@@ -67,15 +74,4 @@ class ConfigurationTest < Test::Unit::TestCase
     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

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

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../../utils"
+require "utils"
 require 'capistrano/recipes/deploy/scm/base'
 
 class DeploySCMBaseTest < Test::Unit::TestCase

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