ol-whisk_deploy 0.6.25

data/spec/integration/remote_deployments_spec.rb

@@ -0,0 +1,166 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'whiskey_disk'))
+
+integration_spec do
+  describe 'when configured for a remote deployment' do
+    before do
+      setup_deployment_area
+    end
+
+    describe 'with a single remote domain' do
+      before do
+        @config = scenario_config('remote/deploy.yml')
+        @args = "--path=#{@config} --to=project:remote"
+      end
+
+      describe 'performing a setup' do
+        it 'performs a checkout of the repository to the target path' do
+          run_setup(@args)
+          File.exists?(deployed_file('project/README')).should == true
+        end
+
+        it 'has the working copy set to the master branch' do
+          run_setup(@args)
+          current_branch('project').should == 'master'
+        end
+
+        it 'has the working copy set to the specified branch when one is available' do
+          @args = "--path=#{@config} --to=project:remote-on-other-branch"
+          run_setup(@args)
+          current_branch('project').should == 'no_rake_hooks'
+        end
+
+        it 'reports the remote setup as successful' do
+          run_setup(@args)
+          File.read(integration_log).should =~ /vagrant => succeeded/
+        end
+
+        it 'exits with a true status' do
+          run_setup(@args).should == true
+        end
+      end
+
+      describe 'performing a deployment' do
+        before do
+          checkout_repo('project')
+          File.unlink(deployed_file('project/README'))  # modify the deployed checkout
+        end
+
+        it 'updates the checkout of the repository on the target path' do
+          run_deploy(@args)
+          File.exists?(deployed_file('project/README')).should == true
+        end
+
+        it 'has the working copy set to the master branch' do
+          run_deploy(@args)
+          current_branch('project').should == 'master'
+        end
+
+        it 'has the working copy set to the specified branch when one is available' do
+          @args = "--path=#{@config} --to=project:remote-on-other-branch"
+          checkout_branch('project', 'no_rake_hooks')
+          run_deploy(@args)
+          current_branch('project').should == 'no_rake_hooks'
+        end
+
+        it 'reports the remote deployment as successful' do
+          run_deploy(@args)
+          File.read(integration_log).should =~ /vagrant => succeeded/
+        end
+
+        it 'exits with a true status' do
+          run_deploy(@args).should == true
+        end
+      end
+
+      describe 'performing a deploy after a setup' do
+        describe 'and using the master branch' do
+          before do
+            run_setup(@args)
+            File.unlink(deployed_file('project/README'))  # modify the deployed checkout
+          end
+
+          it 'updates the checkout of the repository on the target path' do
+            run_deploy(@args)
+            File.exists?(deployed_file('project/README')).should == true
+          end
+
+          it 'has the working copy set to the master branch' do
+            run_deploy(@args)
+            current_branch('project').should == 'master'
+          end
+
+          it 'has the working copy set to the specified branch when one is available' do
+            setup_deployment_area
+
+            @args = "--path=#{@config} --to=project:remote-on-other-branch"
+            run_setup(@args)
+
+            File.unlink(deployed_file('project/README'))
+
+            run_deploy(@args)
+            current_branch('project').should == 'no_rake_hooks'
+          end
+
+          it 'reports the remote deployment as successful' do
+            run_deploy(@args)
+            File.read(integration_log).should =~ /vagrant => succeeded/
+          end
+
+          it 'exits with a true status' do
+            run_deploy(@args).should == true
+          end
+        end
+      end
+    end
+
+    describe 'with ssh options specified' do
+      before do
+        @config = scenario_config('remote/deploy.yml')
+        @args = "--path=#{@config} --to=project:with_ssh_options"
+      end
+
+      describe 'performing a setup' do
+        # TODO FIXME -- this spec fails due to interplay between STDOUT and file buffering in ruby system() (*WTF*)
+        #
+        # it 'uses specified ssh options when performing the setup' do
+        #   run_setup(@args)
+        #   dump_log
+        #   File.read(integration_log).should =~ /ssh.* -t /
+        # end
+
+        it 'reports the remote setup as successful' do
+          run_setup(@args)
+          File.read(integration_log).should =~ /vagrant => succeeded/
+        end
+
+        it 'exits with a true status' do
+          run_setup(@args).should == true
+        end
+      end
+
+      describe 'performing a deployment' do
+        before do
+          checkout_repo('project')
+          File.unlink(deployed_file('project/README'))  # modify the deployed checkout
+        end
+
+        # TODO FIXME -- this spec fails due to interplay between STDOUT and file buffering in ruby system() (*WTF*)
+        #
+        # it 'uses specified ssh options when performing the setup' do
+        #   run_deploy(@args, true)
+        #   File.read(integration_log).should =~ /ssh.* -t /
+        # end
+
+        it 'reports the remote deployment as successful' do
+          run_deploy(@args)
+          File.read(integration_log).should =~ /vagrant => succeeded/
+        end
+
+        it 'exits with a true status' do
+          run_deploy(@args).should == true
+        end
+      end
+    end
+  end
+end

data/spec/integration/staleness_checks_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'whiskey_disk'))
+
+integration_spec do
+  describe 'when configured for a local deployment' do
+    before do
+      setup_deployment_area
+      @config = scenario_config('local/deploy.yml.erb')
+    end
+
+    describe 'when staleness checkes are enabled' do
+      before do
+        @args = "--path=#{@config} --to=project:local-default --check"
+      end
+
+      describe 'performing a deployment' do
+        before do
+          checkout_repo('project')
+          File.unlink(deployed_file('project/README'))  # modify the deployed checkout
+        end
+
+        it 'does not update the checkout of the repository on the target path' do
+          run_deploy(@args)
+          File.exists?(deployed_file('project/README')).should == false
+        end
+
+        it 'reports the local deployment as successful' do
+          run_deploy(@args)
+          File.read(integration_log).should =~ /local => succeeded/
+        end
+
+        it 'exits with a true status' do
+          run_deploy(@args).should == true
+        end
+      end
+    end
+  end
+
+  describe 'when configured for a remote deployment' do
+    before do
+      setup_deployment_area
+      @config = scenario_config('remote/deploy.yml')
+    end
+
+    describe 'when staleness checkes are enabled' do
+      before do
+        @args = "--path=#{@config} --to=project:remote --check"
+      end
+
+      describe 'performing a deployment' do
+        before do
+          checkout_repo('project')
+          File.unlink(deployed_file('project/README'))  # modify the deployed checkout
+        end
+
+        it 'does not update the checkout of the repository on the target path' do
+          run_deploy(@args)
+          File.exists?(deployed_file('project/README')).should == false
+        end
+
+        it 'reports the local deployment as successful' do
+          run_deploy(@args)
+          File.read(integration_log).should =~ /vagrant => succeeded/
+        end
+
+        it 'exits with a true status' do
+          run_deploy(@args).should == true
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,117 @@
+require 'rubygems'
+require 'bacon'
+require 'facon'
+require 'fileutils'
+require 'tempfile'
+require 'erb'
+
+if ENV['DEBUG'] and ENV['DEBUG'] != ''
+  STDERR.puts "Enabling debugger for spec runs..."
+  require 'rubygems'
+  require 'ruby-debug'
+  Debugger.start
+end
+
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+
+# local target directory, integration spec workspace
+def deployment_root
+  File.expand_path(File.join(File.dirname(__FILE__), '..', 'scenarios', 'setup', 'vagrant', 'deployed', 'target'))
+end
+
+# allow defining an integration spec block
+def integration_spec(&block)
+  yield if ENV['INTEGRATION'] and ENV['INTEGRATION'] != ''
+end
+
+# reset the deployment directory for integration specs
+def setup_deployment_area
+  FileUtils.rm_rf(deployment_root)
+  File.umask(0)
+  Dir.mkdir(deployment_root, 0777)
+  Dir.mkdir(deployed_file('log'), 0777)
+end
+
+# run a wd setup using the provided arguments string
+def run_setup(arguments, debugging = true)
+  wd_path  = File.join(File.dirname(__FILE__), '..', 'bin', 'wd')
+  lib_path = File.join(File.dirname(__FILE__), '..', 'lib')
+  debug = debugging ? '--debug' : ''
+  system("/usr/bin/env ruby -I #{lib_path} -r whiskey_disk -rubygems #{wd_path} setup #{debug} #{arguments} > #{integration_log} 2> #{integration_log}")
+end
+
+def integration_log
+  deployed_file('log/out.txt')
+end
+
+# run a wd setup using the provided arguments string
+def run_deploy(arguments, debugging = true)
+  wd_path  = File.join(File.dirname(__FILE__), '..', 'bin', 'wd')
+  lib_path = File.join(File.dirname(__FILE__), '..', 'lib')
+  debug = debugging ? '--debug' : ''
+  status = system("/usr/bin/env ruby -I #{lib_path} -r whiskey_disk -rubygems #{wd_path} deploy #{debug} #{arguments} > #{integration_log} 2> #{integration_log}")
+  status
+end
+
+# build the correct local path to the deployment configuration for a given scenario
+def scenario_config(path)
+  return erb_scenario_config(path) if path =~ /\.erb$/
+  scenario_config_path(path)
+end
+
+def scenario_config_path(path)
+  File.join(File.dirname(__FILE__), '..', 'scenarios', path)
+end
+
+def erb_scenario_config(path)
+  data = File.read(scenario_config_path(path))
+  converted = erb_eval(data)
+  write_tempfile(converted)
+end
+
+def erb_eval(data)
+  ERB.new(data).result
+end
+
+def write_tempfile(data)
+  tmp_file = Tempfile.new('whiskey_disk_integration_spec_scenario')
+  tmp_file.puts(data)
+  tmp_file.close
+  tmp_file.path
+end
+
+# clone a git repository locally (as if a "wd setup" had been deployed)
+def checkout_repo(repo_name, branch = nil)
+  repo_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'scenarios', 'git_repositories', "#{repo_name}.git"))
+  system("cd #{deployment_root} && git clone #{repo_path} >/dev/null 2>/dev/null && cd #{repo_name} && git remote set-url origin #{remote_url(repo_name)}")
+  checkout_branch(repo_name, branch)
+end
+
+def remote_url(repo)
+  "git://wd-git.example.com/#{repo}.git"
+end
+
+def checkout_branch(repo_name, branch = nil)
+  return unless branch
+  system("cd #{deployment_root}/#{repo_name} && git checkout #{branch} >/dev/null 2>/dev/null")
+end
+
+def jump_to_initial_commit(path)
+  system(%Q(cd #{File.join(deployment_root, path)} && git reset --hard `git log --oneline | tail -1 | awk '{print $1}'` >/dev/null 2>/dev/null))
+end
+
+def run_log
+  File.readlines(integration_log)
+end
+
+def deployed_file(path)
+  File.join(deployment_root, path)
+end
+
+def dump_log
+  STDERR.puts("\n\n\n" + File.read(integration_log) + "\n\n\n")
+end
+
+def current_branch(path)
+  `cd #{deployed_file(path)} && git branch`.split("\n").grep(/^\*/).first.sub(/^\* /, '')
+end

data/spec/wd_command_spec.rb

@@ -0,0 +1,986 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'rake'
+
+def run_command
+  cmd_path = File.expand_path(File.join(File.dirname(__FILE__), *%w[.. bin wd]))
+  path = File.expand_path(File.dirname(cmd_path))
+  file = File.read(cmd_path)
+
+  Dir.chdir(path) do |path|
+    eval(file)
+  end
+end
+
+describe 'wd command' do
+  before do
+    @stderr, @stdout, $stderr, $stdout = $stderr, $stdout, StringIO.new, StringIO.new
+    ENV['to'] = ENV['path'] = nil
+  end
+
+  after do
+    @stderr, @stdout, $stderr, $stdout = $stderr, $stdout, @stderr, @stdout
+  end
+  
+  describe 'when no command-line arguments are specified' do
+    before do
+      Object.send(:remove_const, :ARGV)
+      ARGV = []
+    end  
+    
+    it 'does not run rake tasks' do
+      Rake::Application.should.receive(:new).never
+      lambda { run_command }
+    end
+  
+    it 'exits' do
+      lambda { run_command }.should.raise(SystemExit)
+    end
+    
+    it 'exits with a failure status' do
+      begin
+        run_command
+      rescue Exception => e
+        e.success?.should == false
+      end
+    end
+  end
+
+  it 'outputs usage without a backtrace when --help is specified' do
+    Object.send(:remove_const, :ARGV)
+    ARGV = ['--help']
+    lambda { run_command }.should.raise(SystemExit)
+  end
+  
+  it 'outputs usage without a backtrace when garbage options are specified' do
+    Object.send(:remove_const, :ARGV)
+    ARGV = ['--slkjfsdflkj']
+    lambda { run_command }.should.raise(SystemExit)
+  end
+  
+  describe 'when --version argument is specified' do
+    before do
+      Object.send(:remove_const, :ARGV)
+      ARGV = ['--version']
+    end
+  
+    # it 'outputs the version stored in the VERSION file' do
+    #   version = File.read(File.expand_path(File.join(File.dirname(__FILE__), '..', 'VERSION'))).chomp
+    #   # TODO: capture version output
+    #   lambda{ run_command }
+    # end
+  
+    it 'exits' do
+      lambda { run_command }.should.raise(SystemExit)
+    end
+  
+    it 'exits successfully' do
+      begin
+        run_command
+      rescue SystemExit => e
+        e.success?.should == true
+      end
+    end
+  end
+
+  describe "when the 'setup' command is specified" do
+    before do
+      Object.send(:remove_const, :ARGV)
+      ARGV = ['setup']
+    end  
+
+    describe 'and no target is specified' do    
+      it 'does not run rake tasks' do
+        Rake::Application.should.receive(:new).never
+        lambda { run_command }
+      end
+
+      it 'exits when a target is specified' do
+        lambda { run_command }.should.raise(SystemExit)
+      end
+
+      it 'exits with a failing status when a target is specified' do
+        begin
+          run_command
+        rescue SystemExit => e
+          e.success?.should == false
+        end
+      end
+    end
+
+    
+    describe 'and a --to argument is specified' do
+      before do
+        ARGV.push '--to=foo'
+        @rake = Rake::Task['deploy:setup']
+        @rake.stub!(:invoke)
+      end
+      
+      it 'does not fail' do
+        lambda { run_command }.should.not.raise
+      end
+      
+      it 'runs the deploy:setup rake task' do
+        @rake.should.receive(:invoke)
+        run_command
+      end
+      
+      it 'makes the specified target available as a "to" argument to the rake task' do
+        run_command
+        ENV['to'].should == 'foo'
+      end
+      
+      describe 'and a --path argument is specified' do
+        before do
+          ARGV.push '--path=/path/to/foo'
+        end
+        
+        it 'makes the specified path available as a "path" argument to the rake task' do
+          run_command
+          ENV['path'].should == '/path/to/foo'
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and a -p argument is specified' do
+        before do
+          ARGV.push '-p'
+          ARGV.push '/path/to/foo'
+        end
+        
+        it 'makes the specified path available as a "path" argument to the rake task' do
+          run_command
+          ENV['path'].should == '/path/to/foo'
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and no --path or -p argument is specified' do
+        it 'does not make a "path" argument available to the rake task' do
+          ENV['path'].should.be.nil
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and a --only argument is specified' do
+        before do
+          @domain = 'smeghost'
+          ARGV.push "--only=#{@domain}"
+        end
+
+        it 'makes the specified domain available as an "only" argument to the rake task' do
+          run_command
+          ENV['only'].should == @domain
+        end
+
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and a -o argument is specified' do
+        before do
+          @domain = 'smeghost'
+          ARGV.push '-o'
+          ARGV.push @domain
+        end
+
+        it 'makes the specified domain available as an "only" argument to the rake task' do
+          run_command
+          ENV['only'].should == @domain
+        end
+
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and no --only or -o argument is specified' do
+        it 'does not make an "only" argument available to the rake task' do
+          run_command
+          ENV['only'].should.be.nil
+        end
+
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and a --debug argument is specified' do
+        before do
+          ARGV.push '--debug'
+        end
+
+        it 'runs the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+
+        it 'makes the specified target available as a "debug" argument to the rake task' do
+          run_command
+          ENV['debug'].should == 'true'
+        end
+
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and a -d argument is specified' do
+        before do
+          ARGV.push '-d'
+        end
+
+        it 'runs the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+
+        it 'makes the specified target available as a "debug" argument to the rake task' do
+          run_command
+          ENV['debug'].should == 'true'
+        end
+
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and no --debug or -d argument is specified' do
+        it 'does not make a "debug" argument available to the rake task' do
+          run_command
+          ENV['debug'].should.be.nil
+        end
+
+        it 'runs the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+    end
+
+    describe 'and a -t argument is specified' do
+      before do
+        ARGV.push '-t'
+        ARGV.push 'foo'
+        @rake = Rake::Task['deploy:setup']
+        @rake.stub!(:invoke)
+      end
+
+      it 'does not fail' do
+        lambda { run_command }.should.not.raise
+      end
+
+      it 'runs the deploy:setup rake task' do
+        @rake.should.receive(:invoke)
+        run_command
+      end
+
+      it 'makes the specified target available as a "to" argument to the rake task' do
+        run_command
+        ENV['to'].should == 'foo'
+      end
+
+      describe 'and a --path argument is specified' do
+        before do
+          ARGV.push '--path=/path/to/foo'
+        end
+        
+        it 'makes the specified path available as a "path" argument to the rake task' do
+          run_command
+          ENV['path'].should == '/path/to/foo'
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and a -p argument is specified' do
+        before do
+          ARGV.push '-p'
+          ARGV.push '/path/to/foo'
+        end
+        
+        it 'makes the specified path available as a "path" argument to the rake task' do
+          run_command
+          ENV['path'].should == '/path/to/foo'
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and no --path or -p argument is specified' do
+        it 'does not make a "path" argument available to the rake task' do
+          ENV['path'].should.be.nil
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and a --only argument is specified' do
+        before do
+          @domain = 'smeghost'
+          ARGV.push "--only=#{@domain}"
+        end
+
+        it 'makes the specified domain available as an "only" argument to the rake task' do
+          run_command
+          ENV['only'].should == @domain
+        end
+
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and a -o argument is specified' do
+        before do
+          @domain = 'smeghost'
+          ARGV.push '-o'
+          ARGV.push @domain
+        end
+
+        it 'makes the specified domain available as an "only" argument to the rake task' do
+          run_command
+          ENV['only'].should == @domain
+        end
+
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and no --only or -o argument is specified' do
+        it 'does not make an "only" argument available to the rake task' do
+          run_command
+          ENV['only'].should.be.nil
+        end
+
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+    end
+  end
+  
+  describe "when the 'deploy' command is specified" do
+    before do
+      Object.send(:remove_const, :ARGV)
+      ARGV = ['deploy']
+    end  
+
+    describe 'but no target is specified' do
+      it 'does not run rake tasks' do
+        Rake::Application.should.receive(:new).never
+        lambda { run_command }
+      end
+  
+      it 'exits when a target is specified' do
+        lambda { run_command }.should.raise(SystemExit)
+      end
+
+      it 'exits with a failing status when a target is specified' do
+        begin
+          run_command
+        rescue SystemExit => e
+          e.success?.should == false
+        end
+      end
+    end
+    
+    describe 'and a --to argument is specified' do
+      before do
+        ARGV.push '--to=foo'
+        @rake = Rake::Task['deploy:now']
+        @rake.stub!(:invoke)
+      end
+      
+      it 'does not fail' do
+        lambda { run_command }.should.not.raise
+      end
+      
+      it 'runs the deploy:now rake task' do
+        @rake.should.receive(:invoke)
+        run_command
+      end
+      
+      it 'makes the specified target available as a "to" argument to the rake task' do
+        run_command
+        ENV['to'].should == 'foo'
+      end
+    
+      describe 'and a --check argument is specified' do
+        before do
+          ARGV.push '--check'
+          @rake = Rake::Task['deploy:now']
+          @rake.stub!(:invoke)
+        end
+           
+        it 'does not fail' do
+          lambda { run_command }.should.not.raise
+        end
+      
+        it 'runs the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+      
+        it 'makes the specified target available as a "check" argument to the rake task' do
+          run_command
+          ENV['check'].should == 'true'
+        end
+      end
+
+      describe 'and a -c argument is specified' do
+        before do
+          ARGV.push '-c'
+          @rake = Rake::Task['deploy:now']
+          @rake.stub!(:invoke)
+        end
+           
+        it 'does not fail' do
+          lambda { run_command }.should.not.raise
+        end
+      
+        it 'runs the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+      
+        it 'makes the specified target available as a "check" argument to the rake task' do
+          run_command
+          ENV['check'].should == 'true'
+        end
+      end
+
+      describe 'and no --check or -c argument is specified' do        
+        it 'does not make a "check" argument available to the rake task' do          
+          run_command
+          ENV['check'].should.be.nil
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and a --path argument is specified' do
+        before do
+          ARGV.push '--path=/path/to/foo'
+        end
+        
+        it 'makes the specified path available as a "path" argument to the rake task' do
+          run_command
+          ENV['path'].should == '/path/to/foo'
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and a -p argument is specified' do
+        before do
+          ARGV.push '-p'
+          ARGV.push '/path/to/foo'
+        end
+        
+        it 'makes the specified path available as a "path" argument to the rake task' do
+          run_command
+          ENV['path'].should == '/path/to/foo'
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and no --path or -p argument is specified' do        
+        it 'does not make a "path" argument available to the rake task' do
+          run_command
+          ENV['path'].should.be.nil
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and a --only argument is specified' do
+        before do
+          @domain = 'smeghost'
+          ARGV.push "--only=#{@domain}"
+        end
+        
+        it 'makes the specified domain available as an "only" argument to the rake task' do
+          run_command
+          ENV['only'].should == @domain
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and a -o argument is specified' do
+        before do
+          @domain = 'smeghost'
+          ARGV.push '-o'
+          ARGV.push @domain
+        end
+        
+        it 'makes the specified domain available as an "only" argument to the rake task' do
+          run_command
+          ENV['only'].should == @domain
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and no --only or -o argument is specified' do
+        it 'does not make an "only" argument available to the rake task' do
+          run_command
+          ENV['only'].should.be.nil
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+    end
+
+    describe 'and a -t argument is specified' do
+      before do
+        ARGV.push '-t'
+        ARGV.push 'foo'
+        @rake = Rake::Task['deploy:now']
+        @rake.stub!(:invoke)
+      end
+
+      it 'does not fail' do
+        lambda { run_command }.should.not.raise
+      end
+
+      it 'runs the deploy:now rake task' do
+        @rake.should.receive(:invoke)
+        run_command
+      end
+
+      it 'makes the specified target available as a "to" argument to the rake task' do
+        run_command
+        ENV['to'].should == 'foo'
+      end
+  
+      describe 'and a --check argument is specified' do
+        before do
+          ARGV.push '--check'
+          @rake = Rake::Task['deploy:now']
+          @rake.stub!(:invoke)
+        end
+         
+        it 'does not fail' do
+          lambda { run_command }.should.not.raise
+        end
+    
+        it 'runs the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+    
+        it 'makes the specified target available as a "check" argument to the rake task' do
+          run_command
+          ENV['check'].should == 'true'
+        end
+      end
+
+      describe 'and a -c argument is specified' do
+        before do
+          ARGV.push '-c'
+          @rake = Rake::Task['deploy:now']
+          @rake.stub!(:invoke)
+        end
+         
+        it 'does not fail' do
+          lambda { run_command }.should.not.raise
+        end
+    
+        it 'runs the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+    
+        it 'makes the specified target available as a "check" argument to the rake task' do
+          run_command
+          ENV['check'].should == 'true'
+        end
+      end
+
+      describe 'and no --check or -c argument is specified' do        
+        it 'does not make a "check" argument available to the rake task' do          
+          run_command
+          ENV['check'].should.be.nil
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and a --path argument is specified' do
+        before do
+          ARGV.push '--path=/path/to/foo'
+        end
+        
+        it 'makes the specified path available as a "path" argument to the rake task' do
+          run_command
+          ENV['path'].should == '/path/to/foo'
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and a -p argument is specified' do
+        before do
+          ARGV.push '-p'
+          ARGV.push '/path/to/foo'
+        end
+        
+        it 'makes the specified path available as a "path" argument to the rake task' do
+          run_command
+          ENV['path'].should == '/path/to/foo'
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and no --path or -p argument is specified' do
+        it 'does not make a "path" argument available to the rake task' do
+          ENV['path'].should.be.nil
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+          
+      describe 'and a --only argument is specified' do
+        before do
+          @domain = 'smeghost'
+          ARGV.push "--only=#{@domain}"
+        end
+        
+        it 'makes the specified domain available as an "only" argument to the rake task' do
+          run_command
+          ENV['only'].should == @domain
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and a -o argument is specified' do
+        before do
+          @domain = 'smeghost'
+          ARGV.push '-o'
+          ARGV.push @domain
+        end
+        
+        it 'makes the specified domain available as an "only" argument to the rake task' do
+          run_command
+          ENV['only'].should == @domain
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and no --only or -o argument is specified' do
+        it 'does not make an "only" argument available to the rake task' do
+          run_command
+          ENV['only'].should.be.nil
+        end
+      
+        it 'fails if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+      
+        it 'does not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+    end
+  end
+  
+  describe 'and more than one command is specified' do
+    before do
+      Object.send(:remove_const, :ARGV)
+      ARGV = ['frazzlebazzle', 'shizzlebizzle']
+    end
+    
+    describe 'when no target is specified' do
+      it 'exits when a target is specified' do
+        lambda { run_command }.should.raise(SystemExit)
+      end
+
+      it 'exits with a failing status when a target is specified' do
+        begin
+          run_command
+        rescue SystemExit => e
+          e.success?.should == false
+        end
+      end
+    end
+
+    describe 'when a target is specified' do
+      before do
+        ARGV.push('--to=foo')        
+      end
+      
+      it 'exits when a target is specified' do
+        lambda { run_command }.should.raise(SystemExit)
+      end
+
+      it 'exits with a failing status when a target is specified' do
+        begin
+          run_command
+        rescue SystemExit => e
+          e.success?.should == false
+        end
+      end
+    end
+  end
+  
+  describe 'and an unknown command is specified' do
+    before do
+      Object.send(:remove_const, :ARGV)
+      ARGV = ['frazzlebazzle']
+    end
+    
+    describe 'when no target is specified' do
+      it 'exits when a target is specified' do
+        lambda { run_command }.should.raise(SystemExit)
+      end
+
+      it 'exits with a failing status when a target is specified' do
+        begin
+          run_command
+        rescue SystemExit => e
+          e.success?.should == false
+        end
+      end
+    end
+
+    describe 'when a target is specified' do
+      before do
+        ARGV.push('--to=foo')        
+      end
+      
+      it 'exits when a target is specified' do
+        lambda { run_command }.should.raise(SystemExit)
+      end
+
+      it 'exits with a failing status when a target is specified' do
+        begin
+          run_command
+        rescue SystemExit => e
+          e.success?.should == false
+        end
+      end
+    end
+  end
+end