capistrano 2.15.11 → 3.0.0.pre

data/test/configuration/roles_test.rb

@@ -1,157 +0,0 @@
-require "utils"
-require 'capistrano/configuration/roles'
-require 'capistrano/server_definition'
-
-class ConfigurationRolesTest < Test::Unit::TestCase
-  class MockConfig
-    attr_reader :original_initialize_called
-
-    def initialize
-      @original_initialize_called = true
-    end
-
-    include Capistrano::Configuration::Roles
-  end
-
-  def setup
-    @config = MockConfig.new
-  end
-
-  def test_initialize_should_initialize_roles_collection
-    assert @config.original_initialize_called
-    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_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_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
-    @config.role :app, "app1.capistrano.test", "app2.capistrano.test", :extra => :value
-    @config.roles[:app].each do |server|
-      assert_equal({:extra => :value}, server.options)
-    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,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
-
-  # 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
-  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,77 +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, :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

@@ -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