capistrano 2.2.0 → 2.3.0

data/test/command_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/utils"
+require "utils"
 require 'capistrano/command'
 
 class CommandTest < Test::Unit::TestCase
@@ -20,8 +20,7 @@ class CommandTest < Test::Unit::TestCase
   end
 
   def test_command_with_pty_should_request_pty_and_register_success_callback
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
-      ch.expects(:request_pty).with(:want_reply => true)
+    session = setup_for_extracting_channel_action(:request_pty, true) do |ch|
       ch.expects(:exec).with(%(sh -c "ls"))
     end
     Capistrano::Command.new("ls", [session], :pty => true)
@@ -128,7 +127,7 @@ class CommandTest < Test::Unit::TestCase
   end
 
   def test_unsuccessful_pty_request_should_close_channel
-    session = setup_for_extracting_channel_action(:on_failure) do |ch|
+    session = setup_for_extracting_channel_action(:request_pty, false) do |ch|
       ch.expects(:close)
     end
     Capistrano::Command.new("ls", [session], :pty => true)
@@ -158,7 +157,7 @@ class CommandTest < Test::Unit::TestCase
 
   def test_on_request_should_record_exit_status
     data = mock(:read_long => 5)
-    session = setup_for_extracting_channel_action(:on_request, "exit-status", nil, data) do |ch|
+    session = setup_for_extracting_channel_action([:on_request, "exit-status"], data) do |ch|
       ch.expects(:[]=).with(:status, 5)
     end
     Capistrano::Command.new("ls", [session])
@@ -172,34 +171,34 @@ class CommandTest < Test::Unit::TestCase
   end
 
   def test_stop_should_close_all_open_channels
-    sessions = [mock("session", :open_channel => new_channel(false)),
-                mock("session", :open_channel => new_channel(true)),
-                mock("session", :open_channel => new_channel(false))]
+    sessions = [mock_session(new_channel(false)),
+                mock_session(new_channel(true)),
+                mock_session(new_channel(false))]
 
     cmd = Capistrano::Command.new("ls", sessions)
     cmd.stop!
   end
 
   def test_process_should_return_cleanly_if_all_channels_have_zero_exit_status
-    sessions = [mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 0))]
+    sessions = [mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 0))]
     cmd = Capistrano::Command.new("ls", sessions)
     assert_nothing_raised { cmd.process! }
   end
 
   def test_process_should_raise_error_if_any_channel_has_non_zero_exit_status
-    sessions = [mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 1))]
+    sessions = [mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 1))]
     cmd = Capistrano::Command.new("ls", sessions)
     assert_raises(Capistrano::CommandError) { cmd.process! }
   end
 
   def test_command_error_should_include_accessor_with_host_array
-    sessions = [mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 0)),
-                mock("session", :open_channel => new_channel(true, 1))]
+    sessions = [mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 0)),
+                mock_session(new_channel(true, 1))]
     cmd = Capistrano::Command.new("ls", sessions)
 
     begin
@@ -216,43 +215,13 @@ class CommandTest < Test::Unit::TestCase
       ch = mock("channel")
       returns = [false] * (times-1)
       ch.stubs(:[]).with(:closed).returns(*(returns + [true]))
-      con = mock("connection")
-      con.expects(:process).with(true).times(times-1)
-      ch.expects(:connection).times(times-1).returns(con)
       ch.expects(:[]).with(:status).returns(0)
       ch
     end
 
-    sessions = [mock("session", :open_channel => new_channel[5]),
-                mock("session", :open_channel => new_channel[10]),
-                mock("session", :open_channel => new_channel[7])]
-    cmd = Capistrano::Command.new("ls", sessions)
-    assert_nothing_raised { cmd.process! }
-  end
-
-  def test_process_should_ping_all_connections_each_second
-    now = Time.now
-
-    new_channel = Proc.new do
-      ch = mock("channel")
-      ch.stubs(:now => now)
-      def ch.[](key)
-        case key
-        when :status then 0
-        when :closed then Time.now - now < 1.1 ? false : true
-        else raise "unknown key: #{key}"
-        end
-      end
-      con = mock("connection")
-      con.stubs(:process)
-      con.expects(:ping!)
-      ch.stubs(:connection).returns(con)
-      ch
-    end
-
-    sessions = [mock("session", :open_channel => new_channel[]),
-                mock("session", :open_channel => new_channel[]),
-                mock("session", :open_channel => new_channel[])]
+    sessions = [mock_session(new_channel[5]),
+                mock_session(new_channel[10]),
+                mock_session(new_channel[7])]
     cmd = Capistrano::Command.new("ls", sessions)
     assert_nothing_raised { cmd.process! }
   end
@@ -281,6 +250,13 @@ class CommandTest < Test::Unit::TestCase
 
   private
 
+    def mock_session(channel=nil)
+      stub('session', :open_channel => channel,
+        :preprocess => true,
+        :postprocess => true,
+        :listeners => {})
+    end
+
     def new_channel(closed, status=nil)
       ch = mock("channel")
       ch.expects(:[]).with(:closed).returns(closed)
@@ -300,7 +276,11 @@ class CommandTest < Test::Unit::TestCase
 
       channel.stubs(:[]).with(:server).returns(s)
       channel.stubs(:[]).with(:host).returns(s.host)
-      channel.expects(action).yields(channel, *args) if action
+
+      if action
+        action = Array(action)
+        channel.expects(action.first).with(*action[1..-1]).yields(channel, *args)
+      end
 
       yield channel if block_given?
 

data/test/configuration/actions/file_transfer_test.rb

@@ -1,9 +1,10 @@
-require "#{File.dirname(__FILE__)}/../../utils"
+require "utils"
 require 'capistrano/configuration/actions/file_transfer'
 
 class ConfigurationActionsFileTransferTest < Test::Unit::TestCase
   class MockConfig
     include Capistrano::Configuration::Actions::FileTransfer
+    attr_accessor :sessions
   end
 
   def setup
@@ -11,30 +12,31 @@ class ConfigurationActionsFileTransferTest < Test::Unit::TestCase
     @config.stubs(:logger).returns(stub_everything)
   end
 
-  def test_put_should_pass_options_to_execute_on_servers
-    @config.expects(:execute_on_servers).with(:foo => "bar")
-    @config.put("some data", "test.txt", :foo => "bar")
+  def test_put_should_delegate_to_upload
+    @config.expects(:upload).with { |from, to, opts|
+      from.string == "some data" && to == "test.txt" && opts == { :permissions => 0777 } }
+    @config.put("some data", "test.txt", :mode => 0777)
   end
 
-  def test_put_should_delegate_to_Upload_process
-    @config.expects(:execute_on_servers).yields(%w(s1 s2 s3).map { |s| mock(:host => s) })
-    @config.expects(:sessions).times(3).returns(Hash.new{|h,k| h[k] = k.host.to_sym})
-    Capistrano::Upload.expects(:process).with([:s1,:s2,:s3], "test.txt", :data => "some data", :mode => 0777, :logger => @config.logger)
-    @config.put("some data", "test.txt", :mode => 0777)
+  def test_get_should_delegate_to_download_with_once
+    @config.expects(:download).with("testr.txt", "testl.txt", :foo => "bar", :once => true)
+    @config.get("testr.txt", "testl.txt", :foo => "bar")
   end
 
-  def test_get_should_pass_options_execute_on_servers_including_once
-    @config.expects(:execute_on_servers).with(:foo => "bar", :once => true)
-    @config.get("test.txt", "test.txt", :foo => "bar")
+  def test_upload_should_delegate_to_transfer
+    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
+    @config.upload("testl.txt", "testr.txt", :foo => "bar")
   end
 
-  def test_get_should_use_sftp_get_file_to_local_path
-    sftp = mock("sftp", :state => :closed, :connect => true)
-    sftp.expects(:get_file).with("remote.txt", "local.txt")
+  def test_download_should_delegate_to_transfer
+    @config.expects(:transfer).with(:down, "testr.txt", "testl.txt", :foo => "bar")
+    @config.download("testr.txt", "testl.txt", :foo => "bar")
+  end
 
-    s = server("capistrano")
-    @config.expects(:execute_on_servers).yields([s])
-    @config.expects(:sessions).returns(s => mock("session", :sftp => sftp))
-    @config.get("remote.txt", "local.txt")
+  def test_transfer_should_invoke_transfer_on_matching_servers
+    @config.sessions = { :a => 1, :b => 2, :c => 3, :d => 4 }
+    @config.expects(:execute_on_servers).with(:foo => "bar").yields([:a, :b, :c])
+    Capistrano::Transfer.expects(:process).with(:up, "testl.txt", "testr.txt", [1,2,3], {:foo => "bar", :logger => @config.logger})
+    @config.transfer(:up, "testl.txt", "testr.txt", :foo => "bar")
   end
 end

data/test/configuration/actions/inspect_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../../utils"
+require "utils"
 require 'capistrano/configuration/actions/inspect'
 
 class ConfigurationActionsInspectTest < Test::Unit::TestCase

data/test/configuration/actions/invocation_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../../utils"
+require "utils"
 require 'capistrano/configuration/actions/invocation'
 
 class ConfigurationActionsInvocationTest < Test::Unit::TestCase
@@ -97,29 +97,29 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
   end
 
   def test_sudo_should_default_to_sudo
-    @config.expects(:run).with("sudo -p 'sudo password: ' ls", {})
+    @config.expects(:run).with("ls", :command_prefix => "sudo -p 'sudo password: '")
     @config.sudo "ls"
   end
 
   def test_sudo_should_use_sudo_variable_definition
-    @config.expects(:run).with("/opt/local/bin/sudo -p 'sudo password: ' ls", {})
+    @config.expects(:run).with("ls", :command_prefix => "/opt/local/bin/sudo -p 'sudo password: '")
     @config.options[:sudo] = "/opt/local/bin/sudo"
     @config.sudo "ls"
   end
 
   def test_sudo_should_interpret_as_option_as_user
-    @config.expects(:run).with("sudo -p 'sudo password: ' -u app ls", {})
+    @config.expects(:run).with("ls", :command_prefix => "sudo -p 'sudo password: ' -u app")
     @config.sudo "ls", :as => "app"
   end
 
   def test_sudo_should_pass_options_through_to_run
-    @config.expects(:run).with("sudo -p 'sudo password: ' ls", :foo => "bar")
+    @config.expects(:run).with("ls", :command_prefix => "sudo -p 'sudo password: '", :foo => "bar")
     @config.sudo "ls", :foo => "bar"
   end
 
   def test_sudo_should_interpret_sudo_prompt_variable_as_custom_prompt
     @config.set :sudo_prompt, "give it to me: "
-    @config.expects(:run).with("sudo -p 'give it to me: ' ls", {})
+    @config.expects(:run).with("ls", :command_prefix => "sudo -p 'give it to me: '")
     @config.sudo "ls"
   end
 

data/test/configuration/callbacks_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/callbacks'
 
 class ConfigurationCallbacksTest < Test::Unit::TestCase

data/test/configuration/connections_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/connections'
 
 class ConfigurationConnectionsTest < Test::Unit::TestCase
@@ -31,7 +31,7 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
     @config = MockConfig.new
     @config.stubs(:logger).returns(stub_everything)
     @ssh_options = {
-      :user        => "jamis",
+      :user        => "user",
       :port        => 8080,
       :password    => "g00b3r",
       :ssh_options => { :debug => :verbose }
@@ -59,17 +59,16 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
   end
 
   def test_connection_factory_should_return_gateway_instance_if_gateway_variable_is_set
-    @config.values[:gateway] = "capistrano"
-    server = server("capistrano")
-    Capistrano::SSH.expects(:connect).with { |s,| s.host == "capistrano" }.yields(stub_everything)
-    assert_instance_of Capistrano::Gateway, @config.connection_factory
+    @config.values[:gateway] = "j@capistrano"
+    Net::SSH::Gateway.expects(:new).with("capistrano", "j", :port => 22, :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.update(@ssh_options)
-    Capistrano::SSH.expects(:connect).with { |s,opts| s.host == "capistrano" && opts == @config }.yields(stub_everything)
-    assert_instance_of Capistrano::Gateway, @config.connection_factory
+    Net::SSH::Gateway.expects(:new).with("capistrano", "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_establish_connections_to_should_accept_a_single_nonarray_parameter
@@ -194,11 +193,11 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
     @config.current_task = mock_task
     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1")])
     Capistrano::SSH.expects(:connect).raises(Exception)
-    assert_raises(Capistrano::ConnectionError) {
+    assert_raises(Capistrano::ConnectionError) do
       @config.execute_on_servers do
         flunk "expected an exception to be raised"
       end
-    }
+    end
   end
   
   def test_execute_servers_should_not_raise_connection_error_on_failure_with_on_errors_continue
@@ -243,14 +242,14 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
     end
   end
   
-  def test_execute_on_servers_should_not_try_to_connect_to_hosts_with_upload_errors_with_on_errors_continue
+  def test_execute_on_servers_should_not_try_to_connect_to_hosts_with_transfer_errors_with_on_errors_continue
     cap1 = server("cap1")
     cap2 = server("cap2")
     @config.current_task = mock_task(:on_error => :continue)
     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2])
     Capistrano::SSH.expects(:connect).times(2).returns(:success)
     @config.execute_on_servers do |servers|
-      error = Capistrano::UploadError.new
+      error = Capistrano::TransferError.new
       error.hosts = [cap1]
       raise error
     end

data/test/configuration/execution_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/execution'
 require 'capistrano/task_definition'
 

data/test/configuration/loading_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/loading'
 
 class ConfigurationLoadingTest < Test::Unit::TestCase

data/test/configuration/namespace_dsl_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/namespaces'
 
 class ConfigurationNamespacesDSLTest < Test::Unit::TestCase

data/test/configuration/roles_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/configuration/roles'
 require 'capistrano/server_definition'
 

data/test/configuration/servers_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/task_definition'
 require 'capistrano/configuration/servers'
 

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

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

data/test/deploy/scm/accurev_test.rb

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

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/git_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../../utils"
+require "utils"
 require 'capistrano/recipes/deploy/scm/git'
 
 class DeploySCMGitTest < Test::Unit::TestCase
@@ -7,7 +7,7 @@ class DeploySCMGitTest < Test::Unit::TestCase
   end
 
   def setup
-    @config = { }
+    @config = { :repository => "." }
     def @config.exists?(name); key?(name); end
 
     @source = TestSCM.new(@config)
@@ -50,7 +50,11 @@ class DeploySCMGitTest < Test::Unit::TestCase
   end
 
   def test_query_revision
-    assert_equal "git rev-parse HEAD", @source.query_revision('HEAD') { |o| o }
+    revision = @source.query_revision('HEAD') do |o|
+      assert_equal "git ls-remote . HEAD", o
+      "d11006102c07c94e5d54dd0ee63dca825c93ed61\tHEAD"
+    end
+    assert_equal "d11006102c07c94e5d54dd0ee63dca825c93ed61", revision
   end
 
   def test_command_should_be_backwards_compatible
@@ -62,12 +66,12 @@ class DeploySCMGitTest < Test::Unit::TestCase
   def test_sync
     dest = "/var/www"
     rev = 'c2d9e79'
-    assert_equal "cd #{dest} && git fetch origin && git reset --hard #{rev}", @source.sync(rev, dest)
+    assert_equal "cd #{dest} && git fetch --tags origin && git reset --hard #{rev}", @source.sync(rev, dest)
 
     # With :scm_command
     git = "/opt/local/bin/git"
     @config[:scm_command] = git
-    assert_equal "cd #{dest} && #{git} fetch origin && #{git} reset --hard #{rev}", @source.sync(rev, dest)
+    assert_equal "cd #{dest} && #{git} fetch --tags origin && #{git} reset --hard #{rev}", @source.sync(rev, dest)
   end
 
   def test_sync_with_remote
@@ -79,7 +83,7 @@ class DeploySCMGitTest < Test::Unit::TestCase
     @config[:repository] = repository
     @config[:remote] = remote
 
-    assert_equal "cd #{dest} && git config remote.#{remote}.url #{repository} && git config remote.#{remote}.fetch +refs/heads/*:refs/remotes/#{remote}/* && git fetch #{remote} && git reset --hard #{rev}", @source.sync(rev, dest)
+    assert_equal "cd #{dest} && git config remote.#{remote}.url #{repository} && git config remote.#{remote}.fetch +refs/heads/*:refs/remotes/#{remote}/* && git fetch --tags #{remote} && git reset --hard #{rev}", @source.sync(rev, dest)
   end
 
   def test_shallow_clone

data/test/deploy/scm/mercurial_test.rb

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

data/test/deploy/strategy/copy_test.rb

@@ -1,11 +1,12 @@
-require "#{File.dirname(__FILE__)}/../../utils"
+require "utils"
 require 'capistrano/logger'
 require 'capistrano/recipes/deploy/strategy/copy'
 require 'stringio'
 
 class DeployStrategyCopyTest < Test::Unit::TestCase
   def setup
-    @config = { :logger => Capistrano::Logger.new(:output => StringIO.new),
+    @config = { :application => "captest",
+                :logger => Capistrano::Logger.new(:output => StringIO.new),
                 :releases_path => "/u/apps/test/releases",
                 :release_path => "/u/apps/test/releases/1234567890",
                 :real_revision => "154" }
@@ -16,44 +17,31 @@ class DeployStrategyCopyTest < Test::Unit::TestCase
 
   def test_deploy_with_defaults_should_use_tar_gz_and_checkout
     Dir.expects(:tmpdir).returns("/temp/dir")
-    Dir.expects(:chdir).with("/temp/dir").yields
     @source.expects(:checkout).with("154", "/temp/dir/1234567890").returns(:local_checkout)
-
     @strategy.expects(:system).with(:local_checkout)
-    @strategy.expects(:system).with("tar czf 1234567890.tar.gz 1234567890")
-    @strategy.expects(:put).with(:mock_file_contents, "/tmp/1234567890.tar.gz")
-    @strategy.expects(:run).with("cd /u/apps/test/releases && tar xzf /tmp/1234567890.tar.gz && rm /tmp/1234567890.tar.gz")
 
-    mock_file = mock("file")
-    mock_file.expects(:puts).with("154")
-    File.expects(:open).with("/temp/dir/1234567890/REVISION", "w").yields(mock_file)
-    File.expects(:open).with("/temp/dir/1234567890.tar.gz", "rb").yields(StringIO.new).returns(:mock_file_contents)
+    prepare_standard_compress_and_copy!
+    @strategy.deploy!
+  end
 
-    FileUtils.expects(:rm).with("/temp/dir/1234567890.tar.gz")
-    FileUtils.expects(:rm_rf).with("/temp/dir/1234567890")
+  def test_deploy_with_exclusions_should_remove_patterns_from_destination
+    @config[:copy_exclude] = ".git"
+    Dir.expects(:tmpdir).returns("/temp/dir")
+    @source.expects(:checkout).with("154", "/temp/dir/1234567890").returns(:local_checkout)
+    @strategy.expects(:system).with(:local_checkout)
 
+    FileUtils.expects(:rm_rf).with("/temp/dir/1234567890/.git")
+    prepare_standard_compress_and_copy!
     @strategy.deploy!
   end
 
   def test_deploy_with_export_should_use_tar_gz_and_export
     Dir.expects(:tmpdir).returns("/temp/dir")
-    Dir.expects(:chdir).with("/temp/dir").yields
     @config[:copy_strategy] = :export
     @source.expects(:export).with("154", "/temp/dir/1234567890").returns(:local_export)
-
     @strategy.expects(:system).with(:local_export)
-    @strategy.expects(:system).with("tar czf 1234567890.tar.gz 1234567890")
-    @strategy.expects(:put).with(:mock_file_contents, "/tmp/1234567890.tar.gz")
-    @strategy.expects(:run).with("cd /u/apps/test/releases && tar xzf /tmp/1234567890.tar.gz && rm /tmp/1234567890.tar.gz")
-
-    mock_file = mock("file")
-    mock_file.expects(:puts).with("154")
-    File.expects(:open).with("/temp/dir/1234567890/REVISION", "w").yields(mock_file)
-    File.expects(:open).with("/temp/dir/1234567890.tar.gz", "rb").yields(StringIO.new).returns(:mock_file_contents)
-
-    FileUtils.expects(:rm).with("/temp/dir/1234567890.tar.gz")
-    FileUtils.expects(:rm_rf).with("/temp/dir/1234567890")
 
+    prepare_standard_compress_and_copy!
     @strategy.deploy!
   end
 
@@ -79,7 +67,7 @@ class DeployStrategyCopyTest < Test::Unit::TestCase
     @strategy.deploy!
   end
 
-  def test_deploy_with_bzip2_should_use_zip_and_checkout
+  def test_deploy_with_bzip2_should_use_bz2_and_checkout
     Dir.expects(:tmpdir).returns("/temp/dir")
     Dir.expects(:chdir).with("/temp/dir").yields
     @config[:copy_compression] = :bzip2
@@ -144,4 +132,109 @@ class DeployStrategyCopyTest < Test::Unit::TestCase
 
     @strategy.deploy!
   end
+
+  def test_with_copy_cache_should_checkout_to_cache_if_cache_does_not_exist_and_then_copy
+    @config[:copy_cache] = true
+
+    Dir.stubs(:tmpdir).returns("/temp/dir")
+    File.expects(:exists?).with("/temp/dir/captest").returns(false)
+    Dir.expects(:chdir).with("/temp/dir/captest").yields
+
+    @source.expects(:checkout).with("154", "/temp/dir/captest").returns(:local_checkout)
+    @strategy.expects(:system).with(:local_checkout)
+
+    FileUtils.expects(:mkdir_p).with("/temp/dir/1234567890")
+
+    prepare_directory_tree!("/temp/dir/captest")
+
+    prepare_standard_compress_and_copy!
+    @strategy.deploy!
+  end
+
+  def test_with_copy_cache_should_update_cache_if_cache_exists_and_then_copy
+    @config[:copy_cache] = true
+
+    Dir.stubs(:tmpdir).returns("/temp/dir")
+    File.expects(:exists?).with("/temp/dir/captest").returns(true)
+    Dir.expects(:chdir).with("/temp/dir/captest").yields
+
+    @source.expects(:sync).with("154", "/temp/dir/captest").returns(:local_sync)
+    @strategy.expects(:system).with(:local_sync)
+
+    FileUtils.expects(:mkdir_p).with("/temp/dir/1234567890")
+
+    prepare_directory_tree!("/temp/dir/captest")
+
+    prepare_standard_compress_and_copy!
+    @strategy.deploy!
+  end
+
+  def test_with_copy_cache_with_custom_cache_dir_should_use_specified_cache_dir
+    @config[:copy_cache] = "/u/caches/captest"
+
+    Dir.stubs(:tmpdir).returns("/temp/dir")
+    File.expects(:exists?).with("/u/caches/captest").returns(true)
+    Dir.expects(:chdir).with("/u/caches/captest").yields
+
+    @source.expects(:sync).with("154", "/u/caches/captest").returns(:local_sync)
+    @strategy.expects(:system).with(:local_sync)
+
+    FileUtils.expects(:mkdir_p).with("/temp/dir/1234567890")
+
+    prepare_directory_tree!("/u/caches/captest")
+
+    prepare_standard_compress_and_copy!
+    @strategy.deploy!
+  end
+
+  def test_with_copy_cache_with_excludes_should_not_copy_excluded_files
+    @config[:copy_cache] = true
+    @config[:copy_exclude] = "*/bar.txt"
+
+    Dir.stubs(:tmpdir).returns("/temp/dir")
+    File.expects(:exists?).with("/temp/dir/captest").returns(true)
+    Dir.expects(:chdir).with("/temp/dir/captest").yields
+
+    @source.expects(:sync).with("154", "/temp/dir/captest").returns(:local_sync)
+    @strategy.expects(:system).with(:local_sync)
+
+    FileUtils.expects(:mkdir_p).with("/temp/dir/1234567890")
+
+    prepare_directory_tree!("/temp/dir/captest", true)
+
+    prepare_standard_compress_and_copy!
+    @strategy.deploy!
+  end
+
+  private
+
+    def prepare_directory_tree!(cache, exclude=false)
+      Dir.expects(:glob).with("*", File::FNM_DOTMATCH).returns([".", "..", "app", "foo.txt"])
+      File.expects(:directory?).with("app").returns(true)
+      FileUtils.expects(:mkdir).with("/temp/dir/1234567890/app")
+      File.expects(:directory?).with("foo.txt").returns(false)
+      FileUtils.expects(:ln).with("#{cache}/foo.txt", "/temp/dir/1234567890/foo.txt")
+
+      Dir.expects(:glob).with("app/*", File::FNM_DOTMATCH).returns(["app/.", "app/..", "app/bar.txt"])
+
+      unless exclude
+        File.expects(:directory?).with("app/bar.txt").returns(false)
+        FileUtils.expects(:ln).with("#{cache}/app/bar.txt", "/temp/dir/1234567890/app/bar.txt")
+      end
+    end
+
+    def prepare_standard_compress_and_copy!
+      Dir.expects(:chdir).with("/temp/dir").yields
+      @strategy.expects(:system).with("tar czf 1234567890.tar.gz 1234567890")
+      @strategy.expects(:put).with(:mock_file_contents, "/tmp/1234567890.tar.gz")
+      @strategy.expects(:run).with("cd /u/apps/test/releases && tar xzf /tmp/1234567890.tar.gz && rm /tmp/1234567890.tar.gz")
+
+      mock_file = mock("file")
+      mock_file.expects(:puts).with("154")
+      File.expects(:open).with("/temp/dir/1234567890/REVISION", "w").yields(mock_file)
+      File.expects(:open).with("/temp/dir/1234567890.tar.gz", "rb").yields(StringIO.new).returns(:mock_file_contents)
+
+      FileUtils.expects(:rm).with("/temp/dir/1234567890.tar.gz")
+      FileUtils.expects(:rm_rf).with("/temp/dir/1234567890")
+    end
 end