harrison 0.2.0 → 0.3.0

data/lib/harrison/deploy/phase.rb

@@ -0,0 +1,51 @@
+module Harrison
+  class Deploy::Phase
+    attr_accessor :name
+
+    def initialize(name, &phase_config)
+      self.name = name
+
+      @conditions = Array.new
+
+      yield self if block_given?
+    end
+
+    def add_condition(&block)
+      @conditions << block
+    end
+
+    # Ensure all conditions eval to true for this context.
+    def matches_context?(context)
+      @conditions.all? { |cblock| cblock.call(context) }
+    end
+
+    def on_run(&block)
+      @run_block = block
+    end
+
+    def on_fail(&block)
+      @fail_block = block
+    end
+
+    # These should only be invoked by the deploy action.
+    def _run(context)
+      return unless matches_context?(context)
+
+      if @run_block
+        puts "[#{context.host}] Executing \"#{self.name}\"..."
+        @run_block.call(context)
+      end
+    end
+
+    def _fail(context)
+      # Ensure all conditions eval to true for this context.
+      return unless matches_context?(context)
+
+      if @fail_block
+        puts "[#{context.host}] Reverting \"#{self.name}\"..."
+        @fail_block.call(context)
+      end
+
+    end
+  end
+end

data/lib/harrison/package.rb

@@ -23,7 +23,11 @@ module Harrison
     def remote_exec(cmd)
       ensure_remote_dir("#{remote_project_dir}/package")
 
-      super("cd #{remote_project_dir}/package && #{cmd}")
+      if @_remote_context
+        super("cd #{@_remote_context} && #{cmd}")
+      else
+        super("cd #{remote_project_dir}/package && #{cmd}")
+      end
     end
 
     def run(&block)
@@ -40,18 +44,22 @@ module Harrison
       # Fetch/clone git repo on remote host.
       remote_exec("if [ -d cached ] ; then cd cached && git fetch origin -p ; else git clone #{git_src} cached ; fi")
 
-      # Check out target commit.
-      remote_exec("cd cached && git reset --hard #{commit} && git clean -f -d")
-
       # Make a build folder of the target commit.
-      remote_exec("rm -rf #{commit} && cp -a cached #{commit}")
+      remote_exec("rm -rf #{artifact_name(commit)} && cp -a cached #{artifact_name(commit)}")
 
-      # Run user supplied build code.
-      # TODO: alter remote_exec to set directory context to commit dir?
-      super
+      # Check out target commit.
+      remote_exec("cd #{artifact_name(commit)} && git reset --hard #{commit} && git clean -f -d")
+
+      # Run user supplied build code in the context of the checked out code.
+      begin
+        @_remote_context = "#{remote_project_dir}/package/#{artifact_name(commit)}"
+        super
+      ensure
+        @_remote_context = nil
+      end
 
       # Package build folder into tgz.
-      remote_exec("rm -f #{artifact_name(commit)}.tar.gz && cd #{commit} && tar #{excludes_for_tar} -czf ../#{artifact_name(commit)}.tar.gz .")
+      remote_exec("rm -f #{artifact_name(commit)}.tar.gz && cd #{artifact_name(commit)} && tar #{excludes_for_tar} -czf ../#{artifact_name(commit)}.tar.gz .")
 
       if match = remote_regex.match(destination)
         # Copy artifact to remote destination.
@@ -65,7 +73,7 @@ module Harrison
       end
 
       if purge
-        remote_exec("cd .. && rm -rf package")
+        remote_exec("rm -rf #{artifact_name(commit)}")
       end
 
       puts "Sucessfully packaged #{commit} to #{destination}/#{artifact_name(commit)}.tar.gz"

data/lib/harrison/ssh.rb

@@ -14,26 +14,32 @@ module Harrison
     end
 
     def exec(command)
-      puts "INFO (ssh-exec #{desc}): #{command}" if Harrison::DEBUG
+      puts "[#{desc}] INFO: ssh-exec #{command}" if Harrison::DEBUG
 
       result = invoke(@conn, command)
 
       if Harrison::DEBUG || result[:status] != 0
-        warn "STDERR (ssh-exec #{desc}): #{result[:stderr]}" unless result[:stderr].empty?
-        warn "STDOUT (ssh-exec #{desc}): #{result[:stdout]}" unless result[:stdout].empty?
+        warn "[#{desc}] STDERR: #{result[:stderr]}" unless result[:stderr].empty?
+        warn "[#{desc}] STDOUT: #{result[:stdout]}" unless result[:stdout].empty?
       end
 
       (result[:status] == 0) ? result[:stdout] : nil
     end
 
     def download(remote_path, local_path)
-      puts "INFO (scp-down #{desc}): #{local_path} <<< #{remote_path}" if Harrison::DEBUG
+      puts "[#{desc}] INFO: scp-down #{local_path} <<< #{remote_path}" if Harrison::DEBUG
+
       @conn.scp.download!(remote_path, local_path)
+
+      return true
     end
 
     def upload(local_path, remote_path)
-      puts "INFO (scp-up #{desc}): #{local_path} >>> #{remote_path}" if Harrison::DEBUG
+      puts "[#{desc}] INFO: scp-up #{local_path} >>> #{remote_path}" if Harrison::DEBUG
+
       @conn.scp.upload!(local_path, remote_path)
+
+      return true
     end
 
     def close
@@ -68,7 +74,7 @@ module Harrison
 
       conn.open_channel do |channel|
         channel.exec(cmd) do |ch, success|
-          warn "Couldn't execute command (ssh.channel.exec) on remote host: #{cmd}" unless success
+          warn "[#{conn.host}] Couldn't execute command (ssh.channel.exec): #{cmd}" unless success
 
           channel.on_data do |ch,data|
             stdout_data += data

data/lib/harrison/version.rb

@@ -1,3 +1,3 @@
 module Harrison
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/spec_helper.rb

@@ -1,6 +1,9 @@
 require 'bundler/setup'
 Bundler.setup
 
+require 'simplecov'
+SimpleCov.start
+
 require 'harrison'
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration

data/spec/unit/harrison/base_spec.rb

@@ -43,12 +43,8 @@ describe Harrison::Base do
         expect(instance.exec('echo "foo"')).to eq('foo')
       end
 
-      it 'should complain if command returns non-zero' do
-        output = capture(:stderr) do
-          expect(lambda { instance.exec('cat noexist 2>/dev/null') }).to exit_with_code(1)
-        end
-
-        expect(output).to include('unable', 'execute', 'local', 'command')
+      it 'should throw :failure if command returns non-zero' do
+        expect(lambda { instance.exec('cat noexist 2>/dev/null') }).to throw_symbol(:failure)
       end
     end
 
@@ -64,14 +60,9 @@ describe Harrison::Base do
         expect(instance.remote_exec('remote exec')).to eq('remote_exec_return')
       end
 
-      it 'should complain if command returns nil' do
+      it 'should throw :failure if command returns nil' do
         expect(@mock_ssh).to receive(:exec).and_return(nil)
-
-        output = capture(:stderr) do
-          expect(lambda { instance.remote_exec('remote exec fail') }).to exit_with_code(1)
-        end
-
-        expect(output).to include('unable', 'execute', 'remote', 'command')
+        expect(lambda { instance.remote_exec('remote exec fail') }).to throw_symbol(:failure)
       end
     end
 

data/spec/unit/harrison/deploy/phase_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe Harrison::Deploy::Phase do
+  let(:instance) do
+    Harrison::Deploy::Phase.new(:test_phase)
+  end
+
+  describe 'initialize' do
+    it 'should set name' do
+      expect(instance.name).to be :test_phase
+    end
+
+    it 'should yield itself to passed block' do
+      expect { |b| Harrison::Deploy::Phase.new(:block_test, &b) }.to yield_with_args(Harrison::Deploy::Phase)
+    end
+  end
+
+  describe 'instance methods' do
+    describe '#add_condition' do
+      it 'should accept and store a block' do
+        instance.add_condition { |c| true }
+
+        expect(instance.instance_variable_get(:@conditions).size).to be 1
+      end
+    end
+
+    describe '#matches_context?' do
+      it 'should pass the given context to each condition block' do
+        mock_proc = double(:proc)
+        instance.instance_variable_set(:@conditions, [ mock_proc ])
+
+        mock_context = double(:context)
+
+        expect(mock_proc).to receive(:call).with(mock_context)
+
+        instance.matches_context?(mock_context)
+      end
+
+      it 'should be true if all conditions evaluate to true' do
+        instance.instance_variable_set(:@conditions, [
+          Proc.new { |c| true },
+          Proc.new { |c| true },
+          Proc.new { |c| true },
+        ])
+
+        expect(instance.matches_context?(double(:context))).to be true
+      end
+
+      it 'should be false if at least one condition evaluates to false' do
+        instance.instance_variable_set(:@conditions, [
+          Proc.new { |c| true },
+          Proc.new { |c| false },
+          Proc.new { |c| true },
+        ])
+
+        expect(instance.matches_context?(double(:context))).to be false
+      end
+    end
+
+    describe '#on_run' do
+      it 'should store the given block' do
+        instance.on_run { |c| true }
+
+        expect(instance.instance_variable_get(:@run_block)).to_not be_nil
+      end
+    end
+
+    describe '#on_fail' do
+      it 'should store the given block' do
+        instance.on_fail { |c| true }
+
+        expect(instance.instance_variable_get(:@fail_block)).to_not be_nil
+      end
+    end
+
+    describe '#_run' do
+      context 'context matches conditions' do
+        before(:each) do
+          allow(instance).to receive(:matches_context?).and_return(true)
+        end
+
+        it 'should invoke the previously stored block with given context' do
+          mock_context = double(:context, host: 'test_host')
+
+          mock_proc = double(:proc)
+          instance.instance_variable_set(:@run_block, mock_proc)
+
+          expect(mock_proc).to receive(:call).with(mock_context)
+
+          capture(:stdout) do
+            instance._run(mock_context)
+          end
+        end
+      end
+
+      context 'context does not match conditions' do
+        before(:each) do
+          allow(instance).to receive(:matches_context?).and_return(false)
+        end
+
+        it 'should not invoke the previously stored block' do
+          mock_context = double(:context)
+
+          mock_proc = double(:proc)
+          instance.instance_variable_set(:@run_block, mock_proc)
+
+          expect(mock_proc).to_not receive(:call)
+
+          instance._run(mock_context)
+        end
+      end
+    end
+
+    describe '#_fail' do
+      context 'context matches conditions' do
+        before(:each) do
+          allow(instance).to receive(:matches_context?).and_return(true)
+        end
+
+        it 'should invoke the previously stored block with given context' do
+          mock_context = double(:context, host: 'test_host')
+
+          mock_proc = double(:proc)
+          instance.instance_variable_set(:@fail_block, mock_proc)
+
+          expect(mock_proc).to receive(:call).with(mock_context)
+
+          capture(:stdout) do
+            instance._fail(mock_context)
+          end
+        end
+      end
+
+      context 'context does not match conditions' do
+        before(:each) do
+          allow(instance).to receive(:matches_context?).and_return(false)
+        end
+
+        it 'should not invoke the previously stored block' do
+          mock_context = double(:context)
+
+          mock_proc = double(:proc)
+          instance.instance_variable_set(:@fail_block, mock_proc)
+
+          expect(mock_proc).to_not receive(:call)
+
+          instance._fail(mock_context)
+        end
+      end
+    end
+  end
+end

data/spec/unit/harrison/deploy_spec.rb

@@ -22,6 +22,10 @@ describe Harrison::Deploy do
 
       expect(instance.instance_variable_get('@options')).to include(testopt: 'foo')
     end
+
+    it 'should set up default phases' do
+      expect(instance.instance_variable_get(:@_phases)).to_not be_empty
+    end
   end
 
   describe 'instance methods' do
@@ -41,121 +45,249 @@ describe Harrison::Deploy do
       end
     end
 
+    describe '#add_phase' do
+      before(:each) do
+        allow(Harrison::Deploy::Phase).to receive(:new).with(anything)
+      end
+
+      it 'should instantiate a new Phase object with the given name' do
+        expect(Harrison::Deploy::Phase).to receive(:new).with(:test)
+
+        instance.add_phase(:test)
+      end
+
+      it 'should pass a given block to the Phase object constructor' do
+        @mock_phase = double(:phase)
+
+        expect(Harrison::Deploy::Phase).to receive(:new).with(:test).and_yield(@mock_phase)
+        expect(@mock_phase).to receive(:in_block)
+
+        instance.add_phase :test do |p|
+          p.in_block
+        end
+      end
+    end
+
     describe '#remote_exec' do
       before(:each) do
+        instance.base_dir = '/opt'
+        instance.project = 'test_project'
+
         @mock_ssh = double(:ssh)
         expect(instance).to receive(:ssh).and_return(@mock_ssh)
       end
 
       it 'should prepend project dir onto passed command' do
-        instance.base_dir = '/opt'
-        instance.project = 'test_project'
-
         expect(@mock_ssh).to receive(:exec).with("cd /opt/test_project && test_command").and_return('')
 
         instance.remote_exec("test_command")
       end
     end
 
-    describe '#run' do
+    describe '#current_symlink' do
+      it 'starts at base_dir' do
+        expect(instance.current_symlink).to match(/^#{instance.base_dir}/)
+      end
+
+      it 'is not just base_dir' do
+        expect(instance.current_symlink).to_not equal(instance.base_dir)
+      end
+    end
+
+    describe '#update_current_symlink' do
       before(:each) do
-        instance.artifact = 'test_artifact.tar.gz'
-        instance.project = 'test_project'
+        instance.deploy_link = 'new_deploy'
+
+        allow(instance).to receive(:remote_exec).with(/^ln/)
       end
 
-      context 'when passed a block' do
-        it 'should store the block' do
-          test_block = Proc.new { |test| "block_output" }
-          instance.run(&test_block)
+      context 'current_symlink already exists' do
+        before(:each) do
+          expect(instance).to receive(:remote_exec).with(/readlink/).and_return('old_link_target')
+        end
+
+        it 'should store old symlink target' do
+          instance.update_current_symlink
 
-          expect(instance.instance_variable_get("@run_block")).to be test_block
+          expect(instance.instance_variable_get(:@_old_current)).to_not be_nil
+        end
+
+        it 'should replace existing symlink' do
+          expect(instance).to receive(:remote_exec).with(/^ln .* #{instance.deploy_link}/)
+
+          instance.update_current_symlink
         end
       end
 
-      context 'when not passed a block' do
+      context 'current_symlink does not exist yet' do
         before(:each) do
-          @mock_ssh = double(:ssh, host: 'test_host1', exec: '', upload: true, download: true)
-          allow(instance).to receive(:ssh).and_return(@mock_ssh)
+          expect(instance).to receive(:remote_exec).with(/readlink/).and_return('')
+        end
+
+        it 'should not store old symlink target' do
+          instance.update_current_symlink
 
-          instance.instance_variable_set(:@run_block, Proc.new { |h| "block for #{h.host}" })
+          expect(instance.instance_variable_get(:@_old_current)).to be_nil
         end
 
-        it 'should use hosts from --hosts if passed' do
-          instance.instance_variable_set(:@_argv_hosts, [ 'argv_host1', 'argv_host2' ])
+        it 'should create symlink' do
+          expect(instance).to receive(:remote_exec).with(/^ln .* #{instance.deploy_link}/)
 
-          output = capture(:stdout) do
-            instance.run
-          end
+          instance.update_current_symlink
+        end
+      end
+    end
+
+    describe '#revert_current_symlink' do
+      it 'should set link back to old target if old target is set' do
+        instance.instance_variable_set(:@_old_current, 'old_link_target')
+
+        expect(instance).to receive(:remote_exec).with(/^ln .* old_link_target/)
+
+        instance.revert_current_symlink
+      end
+
+      it 'should be a no-op if old target is not set' do
+        expect(instance).to_not receive(:remote_exec)
+
+        instance.revert_current_symlink
+      end
+    end
 
-          expect(instance.hosts).to eq([ 'argv_host1', 'argv_host2' ])
-          expect(output).to include('argv_host1', 'argv_host2')
-          expect(output).to_not include('hf_host')
+    describe '#run' do
+      before(:each) do
+        instance.artifact = 'test_artifact.tar.gz'
+        instance.project = 'test_project'
+
+        @mock_ssh = double(:ssh, host: 'test_host1', exec: '', upload: true, download: true)
+        allow(instance).to receive(:ssh).and_return(@mock_ssh)
+      end
+
+      it 'should use hosts from --hosts if passed' do
+        instance.instance_variable_set(:@_argv_hosts, [ 'argv_host1', 'argv_host2' ])
+
+        output = capture(:stdout) do
+          instance.run
         end
 
-        it 'should use hosts from Harrisonfile if --hosts not passed' do
-          output = capture(:stdout) do
-            instance.run
-          end
+        expect(instance.hosts).to eq([ 'argv_host1', 'argv_host2' ])
+        expect(output).to include('argv_host1', 'argv_host2')
+        expect(output).to_not include('hf_host')
+      end
 
-          expect(instance.hosts).to eq([ 'hf_host' ])
-          expect(output).to include('hf_host')
+      it 'should use hosts from Harrisonfile if --hosts not passed' do
+        output = capture(:stdout) do
+          instance.run
         end
 
-        it 'should require hosts to be set somehow' do
-          instance.hosts = nil
+        expect(instance.hosts).to eq([ 'hf_host' ])
+        expect(output).to include('hf_host')
+      end
 
-          output = capture(:stderr) do
-            expect(lambda { instance.run }).to exit_with_code(1)
-          end
+      it 'should require hosts to be set somehow' do
+        instance.hosts = nil
 
-          expect(output).to include('must', 'specify', 'hosts')
+        output = capture(:stderr) do
+          expect(lambda { instance.run }).to exit_with_code(1)
         end
 
-        it 'should invoke the previously stored block once for each host' do
-          instance.hosts = [ 'host1', 'host2', 'host3' ]
+        expect(output).to include('must', 'specify', 'hosts')
+      end
 
-          output = capture(:stdout) do
-            expect { |b| instance.run(&b); instance.run }.to yield_control.exactly(3).times
-          end
+      it 'should run the specified phases once for each host' do
+        instance.hosts = [ 'host1', 'host2', 'host3' ]
+
+        mock_phase = double(:phase, matches_context?: true)
+        expect(Harrison::Deploy::Phase).to receive(:new).with(:test).and_return(mock_phase)
+        instance.add_phase :test
+        instance.phases = [ :test ]
+
+        expect(mock_phase).to receive(:_run).exactly(3).times
 
-          expect(output).to include('host1', 'host2', 'host3')
+        output = capture(:stdout) do
+          instance.run
         end
 
-        it 'should clean up old releases if passed a --keep option' do
-          instance.keep = 3
+        expect(output).to include('host1', 'host2', 'host3')
+      end
 
-          expect(instance).to receive(:cleanup_deploys).with(3)
-          expect(instance).to receive(:cleanup_releases)
+      context 'when a deployment phase fails on a host' do
+        before(:each) do
+          @upload   = double(:phase, name: :upload, matches_context?: true, _run: true, _fail: true)
+          @extract  = double(:phase, name: :extract, matches_context?: true, _run: true, _fail: true)
+          @link     = double(:phase, name: :link, matches_context?: true)
 
-          output = capture(:stdout) do
-            instance.run
+          allow(@link).to receive(:_run).and_throw(:failure, true)
+
+          instance.instance_variable_set(:@_phases, {
+            upload:   @upload,
+            extract:  @extract,
+            link:     @link,
+          })
+
+          instance.phases = [ :upload, :extract, :link ]
+
+          instance.hosts = [ 'host1', 'host2', 'host3' ]
+        end
+
+        it "should invoke on_fail block for completed phases on each host" do
+          expect(@extract).to receive(:_fail).exactly(3).times.ordered
+          expect(@upload).to receive(:_fail).exactly(3).times.ordered
+
+          capture([ :stdout, :stderr ]) do
+            expect(lambda { instance.run }).to exit_with_code(1)
           end
         end
 
-        context 'when deploying from a remote artifact source' do
-          before(:each) do
-            instance.artifact = 'test_user@test_host1:/tmp/test_artifact.tar.gz'
+        it "should invoke on_fail block on each host in reverse order" do
+          expect(@extract).to receive(:_fail) { |context| expect(context.host).to eq('host3') }.ordered
+          expect(@extract).to receive(:_fail) { |context| expect(context.host).to eq('host2') }.ordered
+          expect(@extract).to receive(:_fail) { |context| expect(context.host).to eq('host1') }.ordered
+
+          capture([ :stdout, :stderr ]) do
+            expect(lambda { instance.run }).to exit_with_code(1)
           end
+        end
+      end
 
-          it 'should invoke scp on the remote host' do
-            allow(instance).to receive(:remote_exec).and_return('')
-            expect(instance).to receive(:remote_exec).with(/scp test_user@test_host1:\/tmp\/test_artifact.tar.gz/).and_return('')
+      context 'when invoked via rollback' do
+        before(:each) do
+          instance.rollback = true
 
-            output = capture(:stdout) do
-              instance.run
-            end
+          instance.project = 'test_project'
 
-            expect(output).to include('deployed', 'test_user', 'test_host1', '/tmp/test_artifact.tar.gz')
+          @mock_ssh = double(:ssh, host: 'test_host1', exec: '', upload: true, download: true)
+          allow(instance).to receive(:ssh).and_return(@mock_ssh)
+        end
+
+        it 'should find the release of the previous deploy' do
+          expect(instance).to receive(:deploys).and_return([ 'deploy_1', 'deploy_2', 'deploy_3', 'deploy_4', 'deploy_5' ])
+          expect(@mock_ssh).to receive(:exec).with(/readlink .* deploy_4/)
+
+          capture(:stdout) do
+            instance.run
           end
+        end
 
-          it 'should not invoke Harrison::SSH.upload' do
-            expect(@mock_ssh).not_to receive(:upload)
+        it 'should not run :upload, :extract, or :cleanup phases' do
+          expect(instance).to receive(:deploys).and_return([ 'deploy_1', 'deploy_2', 'deploy_3', 'deploy_4', 'deploy_5' ])
+          expect(@mock_ssh).to receive(:exec).with(/readlink .* deploy_4/).and_return('old_release')
 
-            output = capture(:stdout) do
-              instance.run
-            end
+          disabled_phase = double(:phase)
+          expect(disabled_phase).to_not receive(:_run)
+
+          enabled_phase = double(:phase, matches_context?: true)
+          expect(enabled_phase).to receive(:_run)
 
-            expect(output).to include('deployed', 'test_user', 'test_host1', '/tmp/test_artifact.tar.gz')
+          instance.instance_variable_set(:@_phases, {
+            upload:   disabled_phase,
+            extract:  disabled_phase,
+            link:     enabled_phase,
+            cleanup:  disabled_phase,
+          })
+
+          capture(:stdout) do
+            instance.run
           end
         end
       end
@@ -220,6 +352,20 @@ describe Harrison::Deploy do
   end
 
   describe 'protected methods' do
+    describe '#add_default_phases' do
+      it 'should add each default phase' do
+        # Trigger constructor invocations so we can only count new invocation below.
+        instance
+
+        expect(Harrison::Deploy::Phase).to receive(:new).with(:upload)
+        expect(Harrison::Deploy::Phase).to receive(:new).with(:extract)
+        expect(Harrison::Deploy::Phase).to receive(:new).with(:link)
+        expect(Harrison::Deploy::Phase).to receive(:new).with(:cleanup)
+
+        instance.send(:add_default_phases)
+      end
+    end
+
     describe '#ssh' do
       it 'should open a new SSH connection to self.host' do
         mock_ssh = double(:ssh)
@@ -316,4 +462,147 @@ describe Harrison::Deploy do
       end
     end
   end
+
+  describe 'default phases' do
+    before(:each) do
+      instance.artifact = '/tmp/test_artifact.tar.gz'
+
+      @mock_ssh = double(:ssh, host: 'test_host1', exec: '', upload: true, download: true)
+      allow(instance).to receive(:ssh).and_return(@mock_ssh)
+    end
+
+    describe 'upload' do
+      before(:each) do
+        @phase = instance.instance_variable_get(:@_phases)[:upload]
+      end
+
+      describe 'on_run' do
+        context 'when deploying from a local artifact' do
+          it 'should invoke Harrison::SSH.upload' do
+            expect(@mock_ssh).to receive(:upload).with(/test_artifact\.tar\.gz/, anything)
+
+            capture(:stdout) do
+              @phase._run(instance)
+            end
+          end
+        end
+
+        context 'when deploying from a remote artifact' do
+          before(:each) do
+            instance.artifact = 'test_user@test_host1:/tmp/test_artifact.tar.gz'
+          end
+
+          it 'should invoke scp on the remote host' do
+            allow(instance).to receive(:remote_exec).and_return('')
+            expect(instance).to receive(:remote_exec).with(/scp test_user@test_host1:\/tmp\/test_artifact.tar.gz/).and_return('')
+
+            capture(:stdout) do
+              @phase._run(instance)
+            end
+          end
+
+          it 'should not invoke Harrison::SSH.upload' do
+            expect(@mock_ssh).not_to receive(:upload)
+
+            capture(:stdout) do
+              @phase._run(instance)
+            end
+          end
+        end
+      end
+
+      describe 'on_fail' do
+        it 'should remove uploaded artifact' do
+          expect(instance).to receive(:remote_exec).with(/rm.*test_artifact\.tar\.gz/)
+
+          capture(:stdout) do
+            @phase._fail(instance)
+          end
+        end
+      end
+    end
+
+    describe 'extract' do
+      before(:each) do
+        @phase = instance.instance_variable_get(:@_phases)[:extract]
+      end
+
+      describe 'on_run' do
+        it 'should untar the artifact and then remove it' do
+          allow(instance).to receive(:remote_exec)
+          expect(instance).to receive(:remote_exec).with(/tar.*test_artifact\.tar\.gz/).ordered
+          expect(instance).to receive(:remote_exec).with(/rm.*test_artifact\.tar\.gz/).ordered
+
+          capture(:stdout) do
+            @phase._run(instance)
+          end
+        end
+      end
+
+      describe 'on_fail' do
+        it 'should remove the extracted release' do
+          expect(instance).to receive(:remote_exec).with(/rm.*#{instance.release_dir}/)
+
+          capture(:stdout) do
+            @phase._fail(instance)
+          end
+        end
+      end
+    end
+
+    describe 'link' do
+      before(:each) do
+        @phase = instance.instance_variable_get(:@_phases)[:link]
+      end
+
+      describe 'on_run' do
+        it 'should create a new deploy link' do
+          expect(instance).to receive(:remote_exec).with(/ln.*#{instance.release_dir}.*#{instance.deploy_link}/)
+
+          capture(:stdout) do
+            @phase._run(instance)
+          end
+        end
+      end
+
+      describe 'on_fail' do
+        it 'should remove deploy link' do
+          expect(instance).to receive(:remote_exec).with(/rm.*#{instance.deploy_link}/)
+
+          capture(:stdout) do
+            @phase._fail(instance)
+          end
+        end
+      end
+    end
+
+    describe 'cleanup' do
+      before(:each) do
+        @phase = instance.instance_variable_get(:@_phases)[:cleanup]
+      end
+
+      describe 'on_run' do
+        it 'should clean up old releases if passed a --keep option' do
+          instance.keep = 3
+
+          expect(instance).to receive(:cleanup_deploys).with(3)
+          expect(instance).to receive(:cleanup_releases)
+
+          capture(:stdout) do
+            @phase._run(instance)
+          end
+        end
+      end
+
+      describe 'on_fail' do
+        it 'should not do anything' do
+          expect(instance).to_not receive(:remote_exec)
+
+          capture(:stdout) do
+            @phase._fail(instance)
+          end
+        end
+      end
+    end
+  end
 end