engineyard-serverside 2.7.0.pre → 2.7.8pre2

data/spec/configuration_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+describe EY::Serverside::Deploy::Configuration do
+  describe "default options" do
+    it "has defaults" do
+      @config = EY::Serverside::Deploy::Configuration.new({
+        'app' => 'app_name',
+        'environment_name' => 'env_name',
+        'account_name' => 'acc',
+        'framework_env' => 'production',
+      })
+      expect(@config.app_name).to eq("app_name")
+      expect(@config.environment_name).to eq("env_name")
+      expect(@config.account_name).to eq("acc")
+      expect(@config.migrate).to eq(nil)
+      expect(@config.migrate?).to eq(false)
+      expect(@config.branch).to eq("master")
+      expect(@config.ref).to eq("master")
+      expect(@config.maintenance_on_migrate).to eq(true)
+      expect(@config.maintenance_on_restart).to eq(true)
+      expect(@config.required_downtime_stack?).to eq(true)
+      expect(@config.framework_env).to eq("production")
+      expect(@config.precompile_assets).to eq("detect")
+      expect(@config.precompile_assets_inferred?).to eq(true)
+      expect(@config.skip_precompile_assets?).to eq(false)
+      expect(@config.precompile_assets?).to eq(false)
+      expect(@config.asset_roles).to eq([:app_master, :app, :solo])
+      expect(@config.user).to eq(ENV['USER'])
+      expect(@config.group).to eq(ENV['USER'])
+      expect(@config.verbose).to eq(false)
+      expect(@config.copy_exclude).to eq([])
+      expect(@config.ignore_database_adapter_warning).to eq(false)
+      expect(@config.ignore_gemfile_lock_warning).to eq(false)
+      expect(@config.bundle_without).to eq(%w[test development])
+      expect(@config.extra_bundle_install_options).to eq(%w[--without test development])
+      expect(@config.deployed_by).to eq("Automation (User name not available)")
+      expect(@config.input_ref).to eq(@config.branch)
+      expect(@config.keep_releases).to eq(3)
+      expect(@config.keep_failed_releases).to eq(3)
+    end
+
+    it "raises when required options are not given" do
+      @config = EY::Serverside::Deploy::Configuration.new({})
+      expect { @config.app_name }.to raise_error
+      expect { @config.environment_name }.to raise_error
+      expect { @config.account_name }.to raise_error
+      expect { @config.framework_env }.to raise_error
+    end
+  end
+
+  context "strategies" do
+    let(:options) do
+      { "app" => "serverside" }
+    end
+
+    it "uses strategy if set" do
+      @config = EY::Serverside::Deploy::Configuration.new(
+        options.merge({'strategy' => 'IntegrationSpec', 'git' => 'git@github.com:engineyard/todo.git'})
+      )
+      capture do # deprecation warning
+        expect(@config.source(test_shell)).to be_a_kind_of(EY::Serverside::Source::IntegrationSpec)
+      end
+      expect(read_output).to include("DEPRECATION WARNING: The configuration key 'strategy' is deprecated in favor of 'source_class'.")
+    end
+
+    it "uses source_class if set" do
+      @config = EY::Serverside::Deploy::Configuration.new(
+        options.merge({'source_class' => 'IntegrationSpec', 'git' => 'git@github.com:engineyard/todo.git'})
+      )
+      expect(@config.source(test_shell)).to be_a_kind_of(EY::Serverside::Source::IntegrationSpec)
+    end
+
+    it "infers a git source" do
+      @config = EY::Serverside::Deploy::Configuration.new(
+        options.merge({ 'git' => 'git@github.com:engineyard/todo.git' })
+      )
+      expect(@config.source(test_shell)).to be_a_kind_of(EY::Serverside::Source::Git)
+    end
+
+    it "infers a archive source" do
+      @config = EY::Serverside::Deploy::Configuration.new(
+        options.merge({'archive' => 'https://github.com/engineyard/todo/archive/master.zip'})
+      )
+
+      expect(@config.source(test_shell)).to be_a_kind_of(EY::Serverside::Source::Archive)
+    end
+  end
+
+  context "command line options" do
+    before do
+      @config = EY::Serverside::Deploy::Configuration.new({
+        'repository_cache' => @tempdir,
+        'app' => 'app_name',
+        'stack' => 'nginx_passenger',
+        'framework_env' => 'development',
+        'environment_name' => 'env_name',
+        'account_name' => 'acc',
+        'branch' => 'branch_from_command_line',
+        'config' => MultiJson.dump({'custom' => 'custom_from_extra_config', 'maintenance_on_migrate' => 'false', 'precompile_assets' => 'false', 'deployed_by' => 'Martin Emde', 'input_ref' => 'input_branch'})
+      })
+    end
+
+    it "underrides options with config (directly supplied options take precedence over 'config' options)" do
+      expect(@config.maintenance_on_migrate).to eq(false)
+      expect(@config.branch).to eq("branch_from_command_line")
+    end
+
+    it "corrects command line supplied precompile_assets string (which relies on having a special not-set value of nil, so can't be a boolean)" do
+      expect(@config.skip_precompile_assets?).to eq(true)
+      expect(@config.precompile_assets?).to eq(false)
+      expect(@config.precompile_assets_inferred?).to eq(false)
+    end
+
+    it "doesn't require downtime on restart for nginx_passenger" do
+      expect(@config.maintenance_on_migrate).to eq(false)
+      expect(@config.maintenance_on_restart).to eq(false)
+    end
+
+    it "doesn't bundle --without the framework_env" do
+      expect(@config.bundle_without).to eq(%w[test])
+    end
+
+    it "gets deployed_by and input_ref correct" do
+      expect(@config.deployed_by).to eq("Martin Emde")
+      expect(@config.input_ref).to eq("input_branch")
+    end
+  end
+
+  describe "ey.yml loading" do
+    before(:each) do
+      @tempdir = `mktemp -d -t ey_yml_spec.XXXXX`.strip
+      @config = EY::Serverside::Deploy::Configuration.new({
+        'repository_cache' => @tempdir,
+        'app' => 'app_name',
+        'environment_name' => 'env_name',
+        'account_name' => 'acc',
+        'migrate' => nil,
+        'branch' => 'branch_from_command_line',
+        'config' => MultiJson.dump({'custom' => 'custom_from_extra_config', 'maintenance_on_migrate' => 'false'})
+      })
+
+      @deploy = FullTestDeploy.new(test_servers, @config, test_shell)
+
+      @yaml_data = {
+        'environments' => {
+          'env_name' => {
+            'copy_exclude' => ['.git'],
+            'migrate' => true,
+            'migration_command' => 'uh oh',
+            'branch' => 'branch_from_ey_yml',
+            'custom' => 'custom_from_ey_yml',
+            'bundle_without' => 'only test',
+            'maintenance_on_migrate' => true,
+          }
+        }
+      }
+    end
+
+    def write_ey_yml(relative_path, data)
+      FileUtils.mkdir_p(File.join(
+        @tempdir,
+        File.dirname(relative_path)))
+
+      File.open(File.join(@tempdir, relative_path), 'w') do |f|
+        f.write data.to_yaml
+      end
+    end
+
+    it "requires 'ey.yml' and adds any defined methods to the deploy" do
+      write_ey_yml 'ey.yml', @yaml_data
+      @deploy.load_ey_yml
+      expect(@deploy.config.copy_exclude).to eq(['.git'])
+    end
+
+    it "falls back to 'config/ey.yml'" do
+      write_ey_yml 'config/ey.yml', @yaml_data
+      @deploy.load_ey_yml
+      expect(@deploy.config.copy_exclude).to eq(['.git'])
+    end
+
+    it "loads at lower priority than command line options" do
+      write_ey_yml 'ey.yml', @yaml_data
+      @deploy.load_ey_yml
+      expect(@deploy.config.migrate?).to eq(false)
+    end
+
+    it "loads at lower priority than json config option" do
+      write_ey_yml 'ey.yml', @yaml_data
+      @deploy.load_ey_yml
+      expect(@deploy.config.branch).to eq('branch_from_command_line')
+    end
+
+    it "loads bundle_without from the config, which overrides the default" do
+      write_ey_yml 'ey.yml', @yaml_data
+      @deploy.load_ey_yml
+      expect(@deploy.config.bundle_without).to eq('only test')
+    end
+
+    it "overrides boolean ey.yml only options with --conifg strings" do
+      write_ey_yml 'ey.yml', @yaml_data
+      @deploy.load_ey_yml
+      expect(@deploy.config).not_to be_maintenance_on_migrate
+    end
+  end
+end

data/spec/custom_deploy_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe "the EY::Serverside::Deploy API" do
+  it "calls tasks in the right order" do
+    class TestDeploy < FullTestDeploy
+      attr_reader :call_order
+      def initialize(*a)
+        super
+        @call_order = []
+      end
+
+      def push_code()                @call_order << 'push_code'               ; super end
+      def copy_repository_cache()    @call_order << 'copy_repository_cache'   ; super end
+      def create_revision_file()     @call_order << 'create_revision_file'    ; super end
+      def bundle()                   @call_order << 'bundle'                  ; super end
+      def setup_services()           @call_order << 'setup_services'          ; super end
+      def symlink_configs()          @call_order << 'symlink_configs'         ; super end
+      def migrate()                  @call_order << 'migrate'                 ; super end
+      def compile_assets()           @call_order << 'compile_assets'          ; super end
+      def symlink()                  @call_order << 'symlink'                 ; super end
+      def restart()                  @call_order << 'restart'                 ; super end
+      def cleanup_old_releases()     @call_order << 'cleanup_old_releases'    ; super end
+      def enable_maintenance_page()  @call_order << 'enable_maintenance_page' ; super end
+      def disable_maintenance_page() @call_order << 'disable_maintenance_page'; super end
+      def gc_repository_cache()      @call_order << 'gc_repository_cache'     ; super end
+    end
+
+    config = EY::Serverside::Deploy::Configuration.new(default_configuration)
+
+    td = TestDeploy.realnew(test_servers, config, test_shell)
+    mock_bundler
+    with_mocked_commands do
+      capture do
+        td.deploy
+      end
+    end
+
+    ############################# IMPORTANT ####################################
+    #
+    # Call order is referenced in the engineyard gem eydeploy.rb documentation.
+    #
+    # https://support.cloud.engineyard.com/entries/20996661-customize-your-deployment
+    #
+    # Changing call order or removing methods may adversely affect customers
+    # that are using eydeploy.rb and relying on this documentation.
+    #
+    ############################################################################
+    expect(td.call_order).to eq(%w(
+      push_code
+      copy_repository_cache
+      create_revision_file
+      bundle
+      setup_services
+      symlink_configs
+      compile_assets
+      enable_maintenance_page
+      migrate
+      symlink
+      restart
+      disable_maintenance_page
+      cleanup_old_releases
+      gc_repository_cache))
+  end
+
+  describe "task overrides" do
+    before(:each) do
+      @tempdir = Pathname.new(`mktemp -d -t custom_deploy_spec.XXXXX`.strip)
+    end
+
+    def write_eydeploy(relative_path, contents = "def got_new_methods() 'from the file on disk' end")
+      path = @tempdir.join(relative_path)
+      path.dirname.mkpath
+      path.open('w') { |f| f << contents }
+    end
+
+    describe "eydeploy_rb disabled" do
+      before do
+        @config = EY::Serverside::Deploy::Configuration.new('app' => 'app_name', 'repository_cache' => @tempdir.to_s, 'eydeploy_rb' => 'false')
+        @deploy = FullTestDeploy.realnew(test_servers, @config, test_shell)
+      end
+
+      it "doesn't load eydeploy_rb file" do
+        write_eydeploy 'eydeploy.rb'
+        @deploy.require_custom_tasks
+        expect(@deploy).not_to respond_to(:got_new_methods)
+      end
+    end
+
+    describe "eydeploy_rb detect or enabled" do
+      before do
+        @config = EY::Serverside::Deploy::Configuration.new('app' => 'app_name', 'repository_cache' => @tempdir.to_s, 'eydeploy_rb' => 'true')
+        @deploy = FullTestDeploy.realnew(test_servers, @config, test_shell)
+      end
+
+      it "requires 'eydeploy.rb' and adds any defined methods to the deploy" do
+        write_eydeploy 'eydeploy.rb'
+        @deploy.require_custom_tasks
+        expect(@deploy.got_new_methods).to eq('from the file on disk')
+      end
+
+      it "falls back to 'config/eydeploy.rb'" do
+        write_eydeploy 'config/eydeploy.rb'
+        @deploy.require_custom_tasks
+        expect(@deploy.got_new_methods).to eq('from the file on disk')
+      end
+
+      it "lets you super up from any defined methods" do
+        write_eydeploy 'eydeploy.rb', "def value() super << ' + derived' end"
+
+        class TestDeploySuper < FullTestDeploy
+          def value() 'base' end
+        end
+
+        deploy = TestDeploySuper.realnew(test_servers, @config, test_shell)
+        deploy.require_custom_tasks
+        expect(deploy.value).to eq("base + derived")
+      end
+
+      it "records exceptions raised from the instance eval in the log" do
+        write_eydeploy 'eydeploy.rb', "raise 'Imma blow up'"
+        expect { @deploy.require_custom_tasks }.to raise_error
+        log = @log_path.read
+        expect(log).to match(/Exception while loading .*eydeploy\.rb/)
+        expect(log).to include('Imma blow up')
+      end
+    end
+  end
+end

data/spec/deploy_hook_spec.rb

@@ -0,0 +1,362 @@
+require 'spec_helper'
+
+describe "deploy hooks" do
+  context "successful deploy with all hooks" do
+    before(:all) do
+      deploy_test_application('hooks')
+    end
+
+    it "runs all the hooks" do
+      expect(deploy_dir.join('current', 'before_deploy.ran' )).to exist
+      expect(deploy_dir.join('current', 'before_bundle.ran' )).to exist
+      expect(deploy_dir.join('current', 'after_bundle.ran'  )).to exist
+      expect(deploy_dir.join('current', 'before_migrate.ran')).to exist
+      expect(deploy_dir.join('current', 'after_migrate.ran' )).to exist
+      expect(deploy_dir.join('current', 'before_compile_assets.ran')).to exist
+      expect(deploy_dir.join('current', 'after_compile_assets.ran' )).to exist
+      expect(deploy_dir.join('current', 'before_symlink.ran')).to exist
+      expect(deploy_dir.join('current', 'after_symlink.ran' )).to exist
+      expect(deploy_dir.join('current', 'before_restart.ran')).to exist
+      expect(deploy_dir.join('current', 'after_restart.ran' )).to exist
+      expect(deploy_dir.join('current', 'after_deploy.ran'  )).to exist
+    end
+  end
+
+  context "with failing deploy hook" do
+    before(:all) do
+      begin
+        deploy_test_application('hook_fails', :verbose => false)
+      rescue EY::Serverside::RemoteFailure
+      end
+    end
+
+    it "prints the failure to the log even when non-verbose" do
+      out = read_output
+      expect(out).to match(%r|FATAL: Exception raised in deploy hook .*/deploy/before_deploy.rb.|)
+      expect(out).to match(%r|RuntimeError:.*Hook failing in \(eval\)|)
+      expect(out).to match(%r|Please fix this error before retrying.|)
+    end
+
+    it "retains the failed release" do
+      release_name = @config.paths.active_release.basename
+      expect(deploy_dir.join('releases_failed', release_name)).to be_directory
+    end
+  end
+
+  context "with an executable for a deploy hook" do
+    before(:all) do
+      deploy_test_application('executable_hooks')
+    end
+
+    it 'runs the hook' do
+      expect(deploy_dir.join('current', 'before_restart.ran')).to exist
+    end
+  end
+
+  context "with a non-executable, but correctly named deploy hook" do
+    before(:all) do
+      deploy_test_application('executable_hooks_not_executable')
+    end
+
+    it 'does not run the hook' do
+      expect(deploy_dir.join('current', 'before_restart.ran')).not_to exist
+    end
+
+    it 'outputs a message about the hook not being executable' do
+      expect(read_output).to match(%r|Skipping.*deploy hook.*not executable|)
+    end
+  end
+
+  context "deploy hook API" do
+    def deploy_hook(options={})
+      config = EY::Serverside::Deploy::Configuration.new({
+        'app' => 'app_name',
+        'framework_env' => 'staging',
+        'current_roles' => ['solo'],
+        'deploy_to'     => deploy_dir.to_s,
+      }.merge(options))
+      # setup to run hooks since a deploy hasn't happened
+      config.paths.new_release!
+      config.paths.active_release.mkpath
+      EY::Serverside::DeployHook.new(config, test_shell, 'fake_test_hook')
+    end
+
+    context "#run" do
+      it "is available" do
+        expect(deploy_hook.eval_hook('respond_to?(:run)')).to be_truthy
+      end
+
+      it "runs commands like the shell does" do
+        ENV['COUNT'] = 'Chocula'
+        File.unlink("/tmp/deploy_hook_spec.the_count") rescue nil
+
+        deploy_hook.eval_hook('run("echo $COUNT > /tmp/deploy_hook_spec.the_count")')
+
+        expect(IO.read("/tmp/deploy_hook_spec.the_count").strip).to eq("Chocula")
+      end
+
+      it "returns true/false to indicate the command's success" do
+        expect(deploy_hook.eval_hook('run("true")')).to be_truthy
+        expect(deploy_hook.eval_hook('run("false")')).to be_falsey
+      end
+
+      it "raises when the bang method alternative is used" do
+        expect {
+          deploy_hook.eval_hook('run!("false")')
+        }.to raise_error(RuntimeError)
+        out = read_output
+        expect(out).to match(%r|FATAL: Exception raised in deploy hook .*/deploy/fake_test_hook.rb.|)
+        expect(out).to match(%r|RuntimeError: .*run!.*Command failed. false|)
+        expect(out).to match(%r|Please fix this error before retrying.|)
+      end
+    end
+
+    context "#sudo" do
+      it "is available" do
+        expect(deploy_hook.eval_hook('respond_to?(:sudo)')).to be_truthy
+      end
+
+      it "runs things with sudo" do
+        hook = deploy_hook
+        mock_sudo do
+          hook.eval_hook('sudo("true") || raise("failed")')
+        end
+      end
+
+      it "raises when the bang method alternative is used" do
+        hook = deploy_hook
+        mock_sudo do
+          expect {
+            hook.eval_hook('sudo!("false")')
+          }.to raise_error(RuntimeError)
+        end
+        out = read_output
+        expect(out).to match(%r|FATAL: Exception raised in deploy hook .*/deploy/fake_test_hook.rb.|)
+        expect(out).to match(%r|RuntimeError: .*sudo!.*Command failed. false|)
+        expect(out).to match(%r|Please fix this error before retrying.|)
+      end
+    end
+
+    context "capistrano-ish methods" do
+      it "has them" do
+        expect(deploy_hook.eval_hook('respond_to?(:latest_release)    ')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:previous_release)  ')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:all_releases)      ')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:current_path)      ')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:shared_path)       ')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:release_dir)       ')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:failed_release_dir)')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:release_path)      ')).to be_truthy
+      end
+
+      it "shows a deprecation warning that asks you to use config to access these variables" do
+        expect(deploy_hook.eval_hook('shared_path.nil?')).to be_falsey
+        out = read_output
+        expect(out).to include("Use of `shared_path` (via method_missing) is deprecated in favor of `config.shared_path` for improved error messages and compatibility.")
+        expect(out).to match(%r|in .*/deploy/fake_test_hook.rb|)
+      end
+    end
+
+    context "access to command line options that should be handed through to the config" do
+      before do
+        @hook = deploy_hook({'app' => 'app', 'environment_name' => 'env', 'account_name' => 'acc'})
+      end
+
+      it "has account_name" do
+        expect(@hook.eval_hook('account_name')).to eq('acc')
+      end
+
+      it "has environment_name" do
+        expect(@hook.eval_hook('environment_name')).to eq('env')
+      end
+
+      it "has app_name" do
+        expect(@hook.eval_hook('app_name')).to eq('app')
+      end
+    end
+
+    context "node" do
+      before(:each) do
+        EY::Serverside.dna_json = MultiJson.dump({
+          'instance_role' => 'solo',
+          'applications' => {
+            'myapp' => {
+              'type' => 'rails',
+              'branch' => 'master',
+            }
+          }
+        })
+      end
+
+      it "is deprecated through the @node ivar" do
+        expect(deploy_hook.eval_hook('@node.nil?')).to be_falsey
+        out = read_output
+        expect(out).to match(%r|Use of `@node` in deploy hooks is deprecated.|)
+        expect(out).to match(%r|Please use `config.node`, which provides access to the same object.|)
+        expect(out).to match(%r|.*/deploy/fake_test_hook.rb|)
+      end
+
+      it "is available" do
+        expect(deploy_hook.eval_hook('config.node.nil?')).to be_falsey
+      end
+
+      it "has indifferent access" do
+        expect(deploy_hook.eval_hook('config.node[:instance_role] ')).to eq('solo')
+        expect(deploy_hook.eval_hook('config.node["instance_role"]')).to eq('solo')
+      end
+
+      it "has deep indifferent access" do
+        expect(deploy_hook.eval_hook('config.node["applications"]["myapp"]["type"]')).to eq('rails')
+        expect(deploy_hook.eval_hook('config.node[:applications]["myapp"][:type]  ')).to eq('rails')
+        expect(deploy_hook.eval_hook('config.node[:applications][:myapp][:type]   ')).to eq('rails')
+      end
+    end
+
+    context "config" do
+      it "is available" do
+        expect(deploy_hook.eval_hook('config.nil?')).to be_falsey
+      end
+
+      it "is deprecated through the @configuration ivar" do
+        expect(deploy_hook.eval_hook('@configuration.nil?')).to be_falsey
+        out = read_output
+        expect(out).to match(%r|Use of `@configuration` in deploy hooks is deprecated.|)
+        expect(out).to match(%r|Please use `config`, which provides access to the same object.|)
+        expect(out).to match(%r|.*/deploy/fake_test_hook.rb|)
+      end
+
+      it "has the configuration in it" do
+        expect(deploy_hook('bert' => 'ernie').eval_hook('config.bert')).to eq('ernie')
+      end
+
+      it "can be accessed with method calls, with [:symbols], or ['strings']" do
+        expect(deploy_hook('bert' => 'ernie').eval_hook('config.bert   ')).to eq('ernie')
+        expect(deploy_hook('bert' => 'ernie').eval_hook('config[:bert] ')).to eq('ernie')
+        expect(deploy_hook('bert' => 'ernie').eval_hook('config["bert"]')).to eq('ernie')
+      end
+
+      [:repository_cache,
+        :release_path,
+        :branch,
+        :shared_path,
+        :deploy_to,
+        :user,
+        :revision,
+        :environment].each do |attribute|
+        it "has the #{attribute.inspect} attribute for compatibility with chef-deploy" do
+          expect(deploy_hook.eval_hook("config.has_key?(#{attribute.inspect})")).to be_truthy
+        end
+      end
+    end
+
+    context "environment variables" do
+      it "sets the framework env variables" do
+        expect(deploy_hook('framework_env' => 'production').eval_hook("ENV['RAILS_ENV']")).to eq('production')
+        expect(deploy_hook('framework_env' => 'production').eval_hook("ENV['RACK_ENV'] ")).to eq('production')
+        expect(deploy_hook('framework_env' => 'production').eval_hook("ENV['MERB_ENV'] ")).to eq('production')
+        expect(deploy_hook('framework_env' => 'production').eval_hook("ENV['NODE_ENV'] ")).to eq('production')
+      end
+    end
+
+    context "has methods to run code only on certain instances" do
+      def scenarios
+        [
+          ['solo'          ],
+          ['app_master'    ],
+          ['app'           ],
+          ['db_master'     ],
+          ['db_slave'      ],
+          ['multi_role,app'],
+          ['multi,util'    ],
+          ['util',         'alpha' ],
+          ['util',         'beta'  ],
+          ['util',         'gamma' ],
+        ]
+      end
+
+      def where_code_runs_with(code)
+        scenarios.select do |role, name|
+          hook = deploy_hook('current_roles' => role.split(','), 'current_name' => name)
+          hook.eval_hook("#{code} { 'ran' } == 'ran'")
+        end.map do |scenario|
+          scenario.compact.join("_")
+        end.compact
+      end
+
+      it "#on_app_master runs on app masters and solos" do
+        expect(where_code_runs_with("on_app_master")).to eq(%w(solo app_master))
+      end
+
+      it "#on_app_servers runs on app masters, app slaves, and solos" do
+        expect(where_code_runs_with("on_app_servers")).to eq(%w(solo app_master app multi_role,app))
+      end
+
+      it "#on_app_servers_and_utilities does what it says on the tin" do
+        expect(where_code_runs_with("on_app_servers_and_utilities")).to eq(
+          %w(solo app_master app multi_role,app multi,util util_alpha util_beta util_gamma)
+        )
+      end
+
+      it "#on_utilities() runs on all utility instances" do
+        expect(where_code_runs_with("on_utilities")).to eq(
+          %w(multi,util util_alpha util_beta util_gamma)
+        )
+      end
+
+      it "#on_utilities('sometype') runs on only utilities of type 'sometype'" do
+        expect(where_code_runs_with("on_utilities('alpha')")).to eq(%w(util_alpha))
+      end
+
+      it "#on_utilities('type1', 'type2') runs on utilities of both types" do
+        expect(where_code_runs_with("on_utilities('alpha', 'beta')")).to eq(
+          %w(util_alpha util_beta)
+        )
+      end
+
+      it "#on_utilities can be invoked with (['a', 'b']) or ('a', 'b')" do
+        expect(where_code_runs_with("on_utilities(%w[alpha beta])")).to eq(
+          where_code_runs_with("on_utilities('alpha', 'beta')")
+        )
+      end
+    end
+
+    context "#syntax_error" do
+      it "returns nil for hook files containing valid Ruby syntax" do
+        hook_path = File.expand_path('../fixtures/valid_hook.rb', __FILE__)
+        expect(deploy_hook.syntax_error(hook_path)).to be_nil
+      end
+
+      it "returns a brief problem description for hook files containing valid Ruby syntax" do
+        hook_path = File.expand_path('../fixtures/invalid_hook.rb', __FILE__)
+        error = Regexp.escape("spec/fixtures/invalid_hook.rb:1: syntax error, unexpected '^'")
+        expect(deploy_hook.syntax_error(hook_path)).to match(/#{error}/)
+      end
+    end
+
+    context "errors in hooks" do
+      it "shows the error in a helpful way" do
+        expect {
+          deploy_hook.eval_hook('methedo_no_existo')
+        }.to raise_error(NameError)
+        out = read_output
+        expect(out).to match(%r|FATAL: Exception raised in deploy hook .*/deploy/fake_test_hook.rb.|)
+        expect(out).to match(%r|NameError: undefined local variable or method `methedo_no_existo' for|)
+        expect(out).to match(%r|Please fix this error before retrying.|)
+      end
+    end
+
+    context "is compatible with older deploy hook scripts" do
+      it "#current_role returns the first role" do
+        expect(deploy_hook('current_roles' => %w(a b)).eval_hook('current_role')).to eq('a')
+      end
+
+      it "has info, warning, debug, logged_system, and access to shell" do
+        expect(deploy_hook.eval_hook('respond_to?(:info)         ')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:warning)      ')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:debug)        ')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:logged_system)')).to be_truthy
+        expect(deploy_hook.eval_hook('respond_to?(:shell)        ')).to be_truthy
+      end
+    end
+  end
+end