capistrano 2.8.0 → 3.19.0

data/test/configuration/servers_test.rb

@@ -1,183 +0,0 @@
-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
-  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_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.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
-    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
-  
-  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,190 +0,0 @@
-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_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)
-    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

@@ -1,88 +0,0 @@
-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

data/test/deploy/local_dependency_test.rb

@@ -1,76 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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_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
-end

data/test/deploy/scm/accurev_test.rb

@@ -1,23 +0,0 @@
-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