engineyard-serverside 2.3.9 → 2.4.0

data/spec/custom_deploy_spec.rb

@@ -58,7 +58,7 @@ describe "the EY::Serverside::Deploy API" do
     # that are using eydeploy.rb and relying on this documentation.
     #
     ############################################################################
-    td.call_order.should == %w(
+    expect(td.call_order).to eq(%w(
       push_code
       copy_repository_cache
       create_revision_file
@@ -72,7 +72,7 @@ describe "the EY::Serverside::Deploy API" do
       restart
       disable_maintenance_page
       cleanup_old_releases
-      gc_repository_cache)
+      gc_repository_cache))
   end
 
   describe "task overrides" do
@@ -95,7 +95,7 @@ describe "the EY::Serverside::Deploy API" do
       it "doesn't load eydeploy_rb file" do
         write_eydeploy 'eydeploy.rb'
         @deploy.require_custom_tasks
-        @deploy.should_not respond_to(:got_new_methods)
+        expect(@deploy).not_to respond_to(:got_new_methods)
       end
     end
 
@@ -108,13 +108,13 @@ describe "the EY::Serverside::Deploy API" do
       it "requires 'eydeploy.rb' and adds any defined methods to the deploy" do
         write_eydeploy 'eydeploy.rb'
         @deploy.require_custom_tasks
-        @deploy.got_new_methods.should == 'from the file on disk'
+        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
-        @deploy.got_new_methods.should == 'from the file on disk'
+        expect(@deploy.got_new_methods).to eq('from the file on disk')
       end
 
       it "lets you super up from any defined methods" do
@@ -126,15 +126,15 @@ describe "the EY::Serverside::Deploy API" do
 
         deploy = TestDeploySuper.realnew(test_servers, @config, test_shell)
         deploy.require_custom_tasks
-        deploy.value.should == "base + derived"
+        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'"
-        lambda { @deploy.require_custom_tasks }.should raise_error
+        expect { @deploy.require_custom_tasks }.to raise_error
         log = @log_path.read
-        log.should =~ /Exception while loading .*eydeploy\.rb/
-        log.should include('Imma blow up')
+        expect(log).to match(/Exception while loading .*eydeploy\.rb/)
+        expect(log).to include('Imma blow up')
       end
     end
   end

data/spec/deploy_hook_spec.rb

@@ -7,18 +7,18 @@ describe "deploy hooks" do
     end
 
     it "runs all the hooks" do
-      deploy_dir.join('current', 'before_deploy.ran' ).should exist
-      deploy_dir.join('current', 'before_bundle.ran' ).should exist
-      deploy_dir.join('current', 'after_bundle.ran'  ).should exist
-      deploy_dir.join('current', 'before_migrate.ran').should exist
-      deploy_dir.join('current', 'after_migrate.ran' ).should exist
-      deploy_dir.join('current', 'before_compile_assets.ran').should exist
-      deploy_dir.join('current', 'after_compile_assets.ran' ).should exist
-      deploy_dir.join('current', 'before_symlink.ran').should exist
-      deploy_dir.join('current', 'after_symlink.ran' ).should exist
-      deploy_dir.join('current', 'before_restart.ran').should exist
-      deploy_dir.join('current', 'after_restart.ran' ).should exist
-      deploy_dir.join('current', 'after_deploy.ran'  ).should exist
+      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
 
@@ -32,14 +32,24 @@ describe "deploy hooks" do
 
     it "prints the failure to the log even when non-verbose" do
       out = read_output
-      out.should =~ %r|FATAL: Exception raised in deploy hook .*/before_migrate.rb.|
-      out.should =~ %r|RuntimeError:.*Hook failing in \(eval\)|
-      out.should =~ %r|Please fix this error before retrying.|
+      expect(out).to match(%r|FATAL: Exception raised in deploy hook .*/before_migrate.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
-      deploy_dir.join('releases_failed', release_name).should be_directory
+      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
+      deploy_dir.join('current', 'before_restart.ran').should exist
     end
   end
 
@@ -56,7 +66,7 @@ describe "deploy hooks" do
 
     context "#run" do
       it "is available" do
-        deploy_hook.eval_hook('respond_to?(:run)').should be_true
+        expect(deploy_hook.eval_hook('respond_to?(:run)')).to be_true
       end
 
       it "runs commands like the shell does" do
@@ -65,28 +75,28 @@ describe "deploy hooks" do
 
         deploy_hook.eval_hook('run("echo $COUNT > /tmp/deploy_hook_spec.the_count")')
 
-        IO.read("/tmp/deploy_hook_spec.the_count").strip.should == "Chocula"
+        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
-        deploy_hook.eval_hook('run("true")').should be_true
-        deploy_hook.eval_hook('run("false")').should be_false
+        expect(deploy_hook.eval_hook('run("true")')).to be_true
+        expect(deploy_hook.eval_hook('run("false")')).to be_false
       end
 
       it "raises when the bang method alternative is used" do
-        lambda {
+        expect {
           deploy_hook.eval_hook('run!("false")')
-        }.should raise_error(RuntimeError)
+        }.to raise_error(RuntimeError)
         out = read_output
-        out.should =~ %r|FATAL: Exception raised in deploy hook /data/app_name/releases/\d+/deploy/fake_test_hook.rb.|
-        out.should =~ %r|RuntimeError: .*run!.*Command failed. false|
-        out.should =~ %r|Please fix this error before retrying.|
+        expect(out).to match(%r|FATAL: Exception raised in deploy hook /data/app_name/releases/\d+/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
-        deploy_hook.eval_hook('respond_to?(:sudo)').should be_true
+        expect(deploy_hook.eval_hook('respond_to?(:sudo)')).to be_true
       end
 
       it "runs things with sudo" do
@@ -99,34 +109,34 @@ describe "deploy hooks" do
       it "raises when the bang method alternative is used" do
         hook = deploy_hook
         mock_sudo do
-          lambda {
+          expect {
             hook.eval_hook('sudo!("false")')
-          }.should raise_error(RuntimeError)
+          }.to raise_error(RuntimeError)
         end
         out = read_output
-        out.should =~ %r|FATAL: Exception raised in deploy hook /data/app_name/releases/\d+/deploy/fake_test_hook.rb.|
-        out.should =~ %r|RuntimeError: .*sudo!.*Command failed. false|
-        out.should =~ %r|Please fix this error before retrying.|
+        expect(out).to match(%r|FATAL: Exception raised in deploy hook /data/app_name/releases/\d+/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
-        deploy_hook.eval_hook('respond_to?(:latest_release)    ').should be_true
-        deploy_hook.eval_hook('respond_to?(:previous_release)  ').should be_true
-        deploy_hook.eval_hook('respond_to?(:all_releases)      ').should be_true
-        deploy_hook.eval_hook('respond_to?(:current_path)      ').should be_true
-        deploy_hook.eval_hook('respond_to?(:shared_path)       ').should be_true
-        deploy_hook.eval_hook('respond_to?(:release_dir)       ').should be_true
-        deploy_hook.eval_hook('respond_to?(:failed_release_dir)').should be_true
-        deploy_hook.eval_hook('respond_to?(:release_path)      ').should be_true
+        expect(deploy_hook.eval_hook('respond_to?(:latest_release)    ')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:previous_release)  ')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:all_releases)      ')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:current_path)      ')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:shared_path)       ')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:release_dir)       ')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:failed_release_dir)')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:release_path)      ')).to be_true
       end
 
       it "shows a deprecation warning that asks you to use config to access these variables" do
-        deploy_hook.eval_hook('shared_path.nil?').should be_false
+        expect(deploy_hook.eval_hook('shared_path.nil?')).to be_false
         out = read_output
-        out.should include("Use of `shared_path` (via method_missing) is deprecated in favor of `config.shared_path` for improved error messages and compatibility.")
-        out.should =~ %r|in /data/app_name/releases/\d+/deploy/fake_test_hook.rb|
+        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 /data/app_name/releases/\d+/deploy/fake_test_hook.rb|)
       end
     end
 
@@ -136,15 +146,15 @@ describe "deploy hooks" do
       end
 
       it "has account_name" do
-        @hook.eval_hook('account_name').should == 'acc'
+        expect(@hook.eval_hook('account_name')).to eq('acc')
       end
 
       it "has environment_name" do
-        @hook.eval_hook('environment_name').should == 'env'
+        expect(@hook.eval_hook('environment_name')).to eq('env')
       end
 
       it "has app_name" do
-        @hook.eval_hook('app_name').should == 'app'
+        expect(@hook.eval_hook('app_name')).to eq('app')
       end
     end
 
@@ -162,50 +172,50 @@ describe "deploy hooks" do
       end
 
       it "is deprecated through the @node ivar" do
-        deploy_hook.eval_hook('@node.nil?').should be_false
+        expect(deploy_hook.eval_hook('@node.nil?')).to be_false
         out = read_output
-        out.should =~ %r|Use of `@node` in deploy hooks is deprecated.|
-        out.should =~ %r|Please use `config.node`, which provides access to the same object.|
-        out.should =~ %r|/data/app_name/releases/\d+/deploy/fake_test_hook.rb|
+        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|/data/app_name/releases/\d+/deploy/fake_test_hook.rb|)
       end
 
       it "is available" do
-        deploy_hook.eval_hook('config.node.nil?').should be_false
+        expect(deploy_hook.eval_hook('config.node.nil?')).to be_false
       end
 
       it "has indifferent access" do
-        deploy_hook.eval_hook('config.node[:instance_role] ').should == 'solo'
-        deploy_hook.eval_hook('config.node["instance_role"]').should == 'solo'
+        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
-        deploy_hook.eval_hook('config.node["applications"]["myapp"]["type"]').should == 'rails'
-        deploy_hook.eval_hook('config.node[:applications]["myapp"][:type]  ').should == 'rails'
-        deploy_hook.eval_hook('config.node[:applications][:myapp][:type]   ').should == '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')
+        expect(deploy_hook.eval_hook('config.node[:applications][:myapp][:type]   ')).to eq('rails')
       end
     end
 
     context "config" do
       it "is available" do
-        deploy_hook.eval_hook('config.nil?').should be_false
+        expect(deploy_hook.eval_hook('config.nil?')).to be_false
       end
 
       it "is deprecated through the @configuration ivar" do
-        deploy_hook.eval_hook('@configuration.nil?').should be_false
+        expect(deploy_hook.eval_hook('@configuration.nil?')).to be_false
         out = read_output
-        out.should =~ %r|Use of `@configuration` in deploy hooks is deprecated.|
-        out.should =~ %r|Please use `config`, which provides access to the same object.|
-        out.should =~ %r|/data/app_name/releases/\d+/deploy/fake_test_hook.rb|
+        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|/data/app_name/releases/\d+/deploy/fake_test_hook.rb|)
       end
 
       it "has the configuration in it" do
-        deploy_hook('bert' => 'ernie').eval_hook('config.bert').should == 'ernie'
+        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
-        deploy_hook('bert' => 'ernie').eval_hook('config.bert   ').should == 'ernie'
-        deploy_hook('bert' => 'ernie').eval_hook('config[:bert] ').should == 'ernie'
-        deploy_hook('bert' => 'ernie').eval_hook('config["bert"]').should == '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')
+        expect(deploy_hook('bert' => 'ernie').eval_hook('config["bert"]')).to eq('ernie')
       end
 
       [:repository_cache,
@@ -217,17 +227,17 @@ describe "deploy hooks" do
         :revision,
         :environment].each do |attribute|
         it "has the #{attribute.inspect} attribute for compatibility with chef-deploy" do
-          deploy_hook.eval_hook("config.has_key?(#{attribute.inspect})").should be_true
+          expect(deploy_hook.eval_hook("config.has_key?(#{attribute.inspect})")).to be_true
         end
       end
     end
 
     context "environment variables" do
       it "sets the framework env variables" do
-        deploy_hook('framework_env' => 'production').eval_hook("ENV['RAILS_ENV']").should == 'production'
-        deploy_hook('framework_env' => 'production').eval_hook("ENV['RACK_ENV'] ").should == 'production'
-        deploy_hook('framework_env' => 'production').eval_hook("ENV['MERB_ENV'] ").should == 'production'
-        deploy_hook('framework_env' => 'production').eval_hook("ENV['NODE_ENV'] ").should == 'production'
+        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
 
@@ -257,74 +267,78 @@ describe "deploy hooks" do
       end
 
       it "#on_app_master runs on app masters and solos" do
-        where_code_runs_with("on_app_master").should == %w(solo app_master)
+        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
-        where_code_runs_with("on_app_servers").should == %w(solo app_master app multi_role,app)
+        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
-        where_code_runs_with("on_app_servers_and_utilities").should ==
+        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
-        where_code_runs_with("on_utilities").should ==
+        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
-        where_code_runs_with("on_utilities('alpha')").should == %w(util_alpha)
+        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
-        where_code_runs_with("on_utilities('alpha', 'beta')").should ==
+        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
-        where_code_runs_with("on_utilities(%w[alpha beta])").should ==
+        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__)
-        deploy_hook.syntax_error(hook_path).should be_nil
+        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 '^'")
-        deploy_hook.syntax_error(hook_path).should =~ /#{error}/
+        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
-        lambda {
+        expect {
           deploy_hook.eval_hook('methedo_no_existo')
-        }.should raise_error(NameError)
+        }.to raise_error(NameError)
         out = read_output
-        out.should =~ %r|FATAL: Exception raised in deploy hook /data/app_name/releases/\d+/deploy/fake_test_hook.rb.|
-        out.should =~ %r|NameError: undefined local variable or method `methedo_no_existo' for|
-        out.should =~ %r|Please fix this error before retrying.|
+        expect(out).to match(%r|FATAL: Exception raised in deploy hook /data/app_name/releases/\d+/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
-        deploy_hook('current_roles' => %w(a b)).eval_hook('current_role').should == 'a'
+        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
-        deploy_hook.eval_hook('respond_to?(:info)         ').should be_true
-        deploy_hook.eval_hook('respond_to?(:warning)      ').should be_true
-        deploy_hook.eval_hook('respond_to?(:debug)        ').should be_true
-        deploy_hook.eval_hook('respond_to?(:logged_system)').should be_true
-        deploy_hook.eval_hook('respond_to?(:shell)        ').should be_true
+        expect(deploy_hook.eval_hook('respond_to?(:info)         ')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:warning)      ')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:debug)        ')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:logged_system)')).to be_true
+        expect(deploy_hook.eval_hook('respond_to?(:shell)        ')).to be_true
       end
     end
   end

data/spec/deprecation_spec.rb

@@ -13,11 +13,11 @@ describe EY::Serverside do
   end
 
   it "deprecates EY::Serverside::LoggedOutput for EY::Serverside::Shell::Helpers" do
-    EY::Serverside::LoggedOutput.should == EY::Serverside::Shell::Helpers
-    @warnings.string.should include("EY::Serverside::LoggedOutput")
+    expect(EY::Serverside::LoggedOutput).to eq(EY::Serverside::Shell::Helpers)
+    expect(@warnings.string).to include("EY::Serverside::LoggedOutput")
   end
 
   it "doesn't interfere with unrelated constants" do
-    lambda{ EY::Serverside::WTFNotDefined }.should raise_error(NameError, /uninitialized constant.*WTFNotDefined/)
+    expect{ EY::Serverside::WTFNotDefined }.to raise_error(NameError, /uninitialized constant.*WTFNotDefined/)
   end
 end

data/spec/ey_yml_customized_deploy_spec.rb

@@ -7,11 +7,11 @@ describe "Deploying an app with ey.yml" do
     end
 
     it "does not migrate even though ey.yml says migrate: true" do
-      read_output.should_not =~ /Migrating/
+      expect(read_output).not_to match(/Migrating/)
     end
 
     it "does not enable the maintenance page at all" do
-      deploy_dir.join('current','maintenance_disabled').should exist
+      expect(deploy_dir.join('current','maintenance_disabled')).to exist
     end
   end
 
@@ -23,45 +23,45 @@ describe "Deploying an app with ey.yml" do
 
     it "excludes copy_excludes from releases" do
       cmd = @deployer.commands.grep(/rsync -aq/).first
-      cmd.should include('rsync -aq --exclude=".git" --exclude="README"')
-      deploy_dir.join('current', '.git').should_not exist
-      deploy_dir.join('current', 'README').should_not exist
+      expect(cmd).to include('rsync -aq --exclude=".git" --exclude="README"')
+      expect(deploy_dir.join('current', '.git')).not_to exist
+      expect(deploy_dir.join('current', 'README')).not_to exist
     end
 
     it "loads ey.yml at lower priority than command line options" do
-      deploy_dir.join('current', 'REVISION').read.should == "somebranch\n"
+      expect(deploy_dir.join('current', 'REVISION').read).to eq("somebranch\n")
     end
 
     it "loads bundle_without from the config, which overrides the default (and 'defaults:' in ey.yml)" do
       cmd = @deployer.commands.grep(/bundle _\S*_ install/).first
-      cmd.should include('--without only test')
+      expect(cmd).to include('--without only test')
     end
 
     it "does not enable the maintenance page during migrations" do
-      deploy_dir.join('current','maintenance_disabled').should exist
-      deploy_dir.join('current','maintenance_enabled').should_not exist
+      expect(deploy_dir.join('current','maintenance_disabled')).to exist
+      expect(deploy_dir.join('current','maintenance_enabled')).not_to exist
     end
 
     it "does not remove an existing maintenance page" do
       maintenance = EY::Serverside::Maintenance.new(test_servers, @config, test_shell)
       deploy_dir.join('current','maintenance_disabled').delete
       maintenance.manually_enable
-      deploy_dir.join('shared','system','maintenance.html').should exist
+      expect(deploy_dir.join('shared','system','maintenance.html')).to exist
       redeploy_test_application
-      read_output.should =~ /Maintenance page is still up./
-      deploy_dir.join('shared','system','maintenance.html').should exist
-      deploy_dir.join('current','maintenance_disabled').should_not exist
-      deploy_dir.join('current','maintenance_enabled').should exist
+      expect(read_output).to match(/Maintenance page is still up./)
+      expect(deploy_dir.join('shared','system','maintenance.html')).to exist
+      expect(deploy_dir.join('current','maintenance_disabled')).not_to exist
+      expect(deploy_dir.join('current','maintenance_enabled')).to exist
       maintenance.manually_disable
-      deploy_dir.join('shared','system','maintenance.html').should_not exist
+      expect(deploy_dir.join('shared','system','maintenance.html')).not_to exist
     end
 
     it "makes custom variables available to hooks" do
-      deploy_dir.join('current', 'custom_hook').read.should include("custom_from_ey_yml")
+      expect(deploy_dir.join('current', 'custom_hook').read).to include("custom_from_ey_yml")
     end
 
     it "doesn't display the database adapter warning with ignore_database_adapter_warning: true" do
-      read_output.should_not =~ /WARNING/
+      expect(read_output).not_to match(/WARNING/)
     end
   end
 
@@ -74,12 +74,12 @@ describe "Deploying an app with ey.yml" do
     end
 
     it "always installs maintenance pages" do
-      deploy_dir.join('current','maintenance_enabled').should exist
-      deploy_dir.join('current','maintenance_disabled').should_not exist
+      expect(deploy_dir.join('current','maintenance_enabled')).to exist
+      expect(deploy_dir.join('current','maintenance_disabled')).not_to exist
     end
 
     it "displays the database adapter warning without ignore_database_adapter_warning" do
-      read_output.should =~ /WARNING: Gemfile.lock does not contain a recognized database adapter./
+      expect(read_output).to match(/WARNING: Gemfile.lock does not contain a recognized database adapter./)
     end
   end
 
@@ -93,7 +93,7 @@ describe "Deploying an app with ey.yml" do
     end
 
     it "doesn't display the database adapter warning" do
-      read_output.should_not =~ /WARNING: Gemfile.lock does not contain a recognized database adapter./
+      expect(read_output).not_to match(/WARNING: Gemfile.lock does not contain a recognized database adapter./)
     end
   end
 end