engineyard-serverside 2.3.9 → 2.4.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTE4NmI1MTllMTQ3MzM0MjQ5MmJlYjQ5ZTRhYjA4Y2QwM2E0ZWE0NA==
+  data.tar.gz: !binary |-
+    MWM0MmQ0YTMxMWRkYzcyZjliZTgwZjI1MGExZTk2ZWY1MWJiMGFkNA==
+SHA512:
+  metadata.gz: !binary |-
+    ZTNiNWE2NTQyOWM0YTUzM2M5MDBjNjVjYTZlYTU5ZmI1NDE1YTNiYTcwMTli
+    Y2YwOWU2YzM4ZGU5MjkwMDJjNmFjN2UwNjQzN2I5ODNiMzYwY2YyZmMzNDkx
+    NTQxMWQyMjdkZTU5ZDZhNmI4ZTMwMmZlYmYxNzcwZGUwYzI0YWM=
+  data.tar.gz: !binary |-
+    OWNjOThiOTU1NzNiNjZkNDRlZWM5Y2U3NmE0MWQzMTkwN2U4ODA1MmU0MzBk
+    Zjc3Yzc2YTVjZWY2OGM0MDBmZmI2OTNkMmQ0ZDg5MGYyYzhmMDc0NGFlYTE2
+    NzgzZjA2YWRmZmUyYjlmYWFhMWZiNWYyOTE4MGJiYWJhNDlhZjY=

data/bin/engineyard-serverside-execute-hook

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+#
+# This script is used to execute non-ruby deploy hooks. It's called from
+# EY::Serverside::Deploy#callback. If you'd like to call it directly you should
+# be careful to replicate everything done in EY::Serverside::Deploy or your
+# hook code may not execute as planned.
+#
+
+set -o nounset
+
+abort() {
+  echo "$*"
+  exit 1
+}
+
+HOOK=${1:-}
+[ -n "${HOOK}" ] || abort "No hook name provided."
+
+# We run all deploy hooks from the root directory of the current release of
+# their app.
+[ -n "${EY_DEPLOY_RELEASE_PATH:-}" ] || abort "EY_DEPLOY_RELEASE_PATH must be set."
+[ -d ${EY_DEPLOY_RELEASE_PATH} ] || abort "EY_DEPLOY_RELEASE_PATH must exist and be a directory"
+cd ${EY_DEPLOY_RELEASE_PATH}
+
+# Run the hook.
+_hook_path=deploy/${HOOK}
+if [ ! \( -f ${_hook_path} -a -x ${_hook_path} \) ]; then
+  abort "${_hook_path} must exist and be executable"
+fi
+exec ${_hook_path}

data/lib/engineyard-serverside/about.rb

@@ -32,6 +32,9 @@ module EY
         File.expand_path("../../../bin/#{gem_name}", __FILE__)
       end
 
+      def hook_executor
+        binary + "-execute-hook"
+      end
     end
   end
 end

data/lib/engineyard-serverside/cli.rb

@@ -93,6 +93,8 @@ module EY
         end
       end
 
+      method_option :ignore_existing, :type     => :boolean,
+                                      :desc     => "When syncing /data/app directory, don't overwrite destination files"
       account_app_env_options
       config_option
       framework_env_option
@@ -124,7 +126,7 @@ module EY
 
           servers.run_for_each! do |server|
             chown = server.command_on_server('sudo sh -l -c', chown_command)
-            sync  = server.sync_directory_command(app_dir)
+            sync  = server.sync_directory_command(app_dir, options[:ignore_existing])
             clean = server.command_on_server('sh -l -c', "rm -rf #{current_app_dir}")
             "(#{chown}) && (#{sync}) && (#{clean})"
           end

data/lib/engineyard-serverside/configuration.rb

@@ -241,6 +241,11 @@ module EY
         )
       end
 
+      # Use [] to access attributes instead of calling methods so
+      # that we get nils instead of NoMethodError.
+      #
+      # Rollback doesn't know about the repository location (nor
+      # should it need to), but it would like to use #short_log_message.
       def paths
         @paths ||= Paths.new({
           :home             => configuration['home_path'],

data/lib/engineyard-serverside/deploy.rb

@@ -337,12 +337,13 @@ YML
       def symlink_tasks
         [
           ["Set group write permissions",           "chmod -R g+w #{paths.active_release}"],
-          ["Remove symlinked shared directories",   "rm -rf #{paths.active_log} #{paths.public_system} #{paths.active_release}/tmp/pids"],
+          ["Remove public/system if symlinked",     "if [ -L \"#{paths.public_system}\" ]; then rm -rf #{paths.public_system}; fi"],
+          ["Remove symlinked shared directories",   "rm -rf #{paths.active_log} #{paths.active_release}/tmp/pids"],
           ["Create tmp directory",                  "mkdir -p #{paths.active_release}/tmp"],
           ["Create public directory",               "mkdir -p #{paths.public}"],
           ["Create config directory",               "mkdir -p #{paths.active_release_config}"],
           ["Symlink shared log directory",          "ln -nfs #{paths.shared_log} #{paths.active_log}"],
-          ["Symlink public system directory",       "ln -nfs #{paths.shared_system} #{paths.public_system}"],
+          ["Symlink public system directory",       "if [ ! -e \"#{paths.public_system}\" ]; then ln -ns #{paths.shared_system} #{paths.public_system}; fi"],
           ["Symlink shared pids directory",         "ln -nfs #{paths.shared}/pids #{paths.active_release}/tmp/pids"],
           ["Symlink other shared config files",     "find #{paths.shared_config} -maxdepth 1 -type f -not -name 'database.yml' -exec ln -s {} #{paths.active_release_config} \\;"],
           ["Symlink database.yml if needed",        "if [ -f \"#{paths.shared_config}/database.yml\" ]; then ln -nfs #{paths.shared_config}/database.yml #{paths.active_release_config}/database.yml; fi"],
@@ -381,6 +382,7 @@ YML
 
       def callback(what)
         @callbacks_reached ||= true
+
         if paths.deploy_hook(what).exist?
           shell.status "Running deploy hook: deploy/#{what}.rb"
           run Escape.shell_command(base_callback_command_for(what)) do |server, cmd|
@@ -390,14 +392,16 @@ YML
             per_instance_args << '--config'        << config.to_json
             cmd << " " << Escape.shell_command(per_instance_args)
           end
+        elsif paths.executable_deploy_hook(what).executable?
+          shell.status "Running deploy hook: deploy/#{what}"
+          run [About.hook_executor, what.to_s].join(' ') do |server, cmd|
+            cmd = hook_env_vars(server).reject{|k,v| v.nil?}.map{|k,v|
+              "#{k}=#{Escape.shell_command([v])}"
+            }.join(' ') + ' ' + config.framework_envs + ' ' + cmd
+          end
         end
       end
 
-      # Use [] to access attributes instead of calling methods so
-      # that we get nils instead of NoMethodError.
-      #
-      # Rollback doesn't know about the repository location (nor
-      # should it need to), but it would like to use #short_log_message.
       def source
         ensure_git_ssh_wrapper
         @source ||= config.source(shell)
@@ -416,6 +420,20 @@ YML
         cmd
       end
 
+      def hook_env_vars(server)
+        {
+          'EY_DEPLOY_ACCOUNT_NAME' => config.account_name,
+          'EY_DEPLOY_APP' => config.app,
+          'EY_DEPLOY_CONFIG' => config.to_json,
+          'EY_DEPLOY_CURRENT_ROLES' => server.roles.to_a.join(' '),
+          'EY_DEPLOY_CURRENT_NAME' => server.name ? server.name.to_s : nil,
+          'EY_DEPLOY_ENVIRONMENT_NAME' => config.environment_name,
+          'EY_DEPLOY_FRAMEWORK_ENV' => config.framework_env.to_s,
+          'EY_DEPLOY_RELEASE_PATH' => paths.active_release.to_s,
+          'EY_DEPLOY_VERBOSE' => (config.verbose ? '1' : '0'),
+        }
+      end
+
       # FIXME: Legacy method, warn and remove.
       def serverside_bin
         About.binary

data/lib/engineyard-serverside/maintenance.rb

@@ -58,8 +58,9 @@ module EY
 
       def enable
         shell.status "Enabling maintenance page."
-        @up = true
         run "mkdir -p #{maintenance_page_dirname}"
+        public_system_symlink_warning
+        @up = true
         run "cp #{source_path} #{enabled_maintenance_page_pathname}"
       end
 
@@ -107,6 +108,18 @@ This application stack does not support no-downtime restarts.
         end
       end
 
+      def public_system_symlink_warning
+        if paths.public_system.realpath != maintenance_page_dirname.realpath
+          shell.warning <<-WARN
+Current repository layout does not allow for maintenance pages!
+Web traffic may still be served to your application.
+
+Expected a symlink at #{paths.public_system}
+
+To use maintenance pages, remove 'public/system' from your repository.
+          WARN
+        end
+      end
     end
   end
 end

data/lib/engineyard-serverside/paths.rb

@@ -108,6 +108,10 @@ module EY
         path(:active_release, 'deploy', "#{hook_name}.rb")
       end
 
+      def executable_deploy_hook(hook_name)
+        path(:active_release, 'deploy', "#{hook_name}")
+      end
+
       def repository_cache
         @repository_cache ||= default_repository_cache
       end

data/lib/engineyard-serverside/server.rb

@@ -34,14 +34,15 @@ module EY
         hostname == 'localhost'
       end
 
-      def sync_directory_command(directory)
+      def sync_directory_command(directory, ignore_existing = false)
         return nil if local?
+        ignore_flag = ignore_existing ? ["--ignore-existing"] : []
         [
           remote_command("mkdir -p #{directory}"),
           # File mod times aren't important during deploy, and
           # -a (archive mode) sets --times which causes problems.
           # -a is equivalent to -rlptgoD. We remove the -t, and add -q.
-          Escape.shell_command(%w[rsync --delete -rlpgoDq -e] + [ssh_command, "#{directory}/", "#{user}@#{hostname}:#{directory}"])
+          Escape.shell_command(%w[rsync --delete -rlpgoDq] + ignore_flag + ["-e", ssh_command, "#{directory}/", "#{user}@#{hostname}:#{directory}"])
         ].join(' && ')
       end
 

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '2.3.9'
+    VERSION = '2.4.0'
   end
 end

data/spec/archive_deploy_spec.rb

@@ -7,8 +7,9 @@ class EY::Serverside::Source::Archive
 end
 
 describe "Deploying a simple application" do
-  let(:adapter) {
-    EY::Serverside::Adapter.new do |args|
+
+  before(:all) do
+    adapter = EY::Serverside::Adapter.new do |args|
       args.account_name = "account"
       args.app = "application_name"
       args.stack = "nginx_unicorn"
@@ -24,13 +25,6 @@ describe "Deploying a simple application" do
         "group"            => GROUP
       }
     end
-  }
-
-  let(:binpath) {
-    File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
-  }
-
-  before(:all) do
     argv = adapter.deploy.commands.last.to_argv[2..-1]
     with_mocked_commands do
       capture do
@@ -54,7 +48,7 @@ describe "Deploying a simple application" do
 
   it "restarts the app servers" do
     restart = deploy_dir.join('current', 'restart')
-    restart.should exist
+    expect(restart).to exist
     expect(restart.read.chomp).to eq(%|LANG="en_US.UTF-8" /engineyard/bin/app_application_name deploy|)
   end
 end

data/spec/basic_deploy_spec.rb

@@ -7,13 +7,13 @@ describe "Deploying a simple application" do
     end
 
     it "creates a REVISION file" do
-      deploy_dir.join('current', 'REVISION').should exist
+      expect(deploy_dir.join('current', 'REVISION')).to exist
     end
 
     it "restarts the app servers" do
       restart = deploy_dir.join('current', 'restart')
-      restart.should exist
-      restart.read.chomp.should == %|LANG="en_US.UTF-8" /engineyard/bin/app_rails31 deploy|
+      expect(restart).to exist
+      expect(restart.read.chomp).to eq(%|LANG="en_US.UTF-8" /engineyard/bin/app_rails31 deploy|)
     end
   end
 end

data/spec/bundler_deploy_spec.rb

@@ -1,47 +1,47 @@
 require 'spec_helper'
 
 describe "Deploying an application that uses Bundler" do
-  let(:version_pattern) { Regexp.quote(::EY::Serverside::DependencyManager::Bundler.default_version) }
+  VERSION_PATTERN = Regexp.quote(::EY::Serverside::DependencyManager::Bundler.default_version)
 
   context "with a Gemfile.lock" do
     before(:all) do
       deploy_test_application('ey_yml')
       @install_bundler_command = @deployer.commands.grep(/gem install bundler/).first
-      @bundle_install_command  = @deployer.commands.grep(/bundle _#{version_pattern}_ install/).first
+      @bundle_install_command  = @deployer.commands.grep(/bundle _#{VERSION_PATTERN}_ install/).first
     end
 
     it "runs the right bundler command" do
-      @install_bundler_command.should_not be_nil
-      @install_bundler_command.should =~ /install bundler .* -v "#{version_pattern}"/
+      expect(@install_bundler_command).not_to be_nil
+      expect(@install_bundler_command).to match(/install bundler .* -v "#{VERSION_PATTERN}"/)
     end
 
     it "runs 'bundle install' with --deployment" do
-      @bundle_install_command.should_not be_nil
-      @bundle_install_command.should include('--deployment')
+      expect(@bundle_install_command).not_to be_nil
+      expect(@bundle_install_command).to include('--deployment')
     end
 
     it "removes bundled_gems directory if the ruby or system version changed" do
       should_run_clear_bundle_cmd = @deployer.commands.grep(/diff/).first
-      should_run_clear_bundle_cmd.should_not be_nil
+      expect(should_run_clear_bundle_cmd).not_to be_nil
       clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
-      clear_bundle_cmd.should_not be_nil
+      expect(clear_bundle_cmd).not_to be_nil
     end
 
     it "has the binstubs in the path when migrating" do
-      deploy_dir.join('path-when-migrating').read.should include('ey_bundler_binstubs')
+      expect(deploy_dir.join('path-when-migrating').read).to include('ey_bundler_binstubs')
     end
 
     it "creates a ruby version file" do
-      deploy_dir.join('shared', 'bundled_gems', 'RUBY_VERSION').should exist
+      expect(deploy_dir.join('shared', 'bundled_gems', 'RUBY_VERSION')).to exist
     end
 
     it "creates a system version file" do
-      deploy_dir.join('shared', 'bundled_gems', 'SYSTEM_VERSION').should exist
+      expect(deploy_dir.join('shared', 'bundled_gems', 'SYSTEM_VERSION')).to exist
     end
 
     it "generates bundler binstubs" do
       pending "doesn't work with mocked bundler" do
-        deploy_dir.join('current', 'ey_bundler_binstubs', 'rake').should exist
+        expect(deploy_dir.join('current', 'ey_bundler_binstubs', 'rake')).to exist
       end
     end
   end
@@ -53,9 +53,9 @@ describe "Deploying an application that uses Bundler" do
 
     it "removes bundled_gems directory if the ruby or system version changed" do
       should_run_clear_bundle_cmd = @deployer.commands.grep(/diff/).first
-      should_run_clear_bundle_cmd.should be_nil
+      expect(should_run_clear_bundle_cmd).to be_nil
       clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
-      clear_bundle_cmd.should_not be_nil
+      expect(clear_bundle_cmd).not_to be_nil
     end
 
   end
@@ -66,13 +66,13 @@ describe "Deploying an application that uses Bundler" do
     end
 
     it "does not run bundler commands" do
-      @deployer.commands.grep(/gem install bundler/).should be_empty
-      @deployer.commands.grep(/bundle _.*_ install/).should be_empty
+      expect(@deployer.commands.grep(/gem install bundler/)).to be_empty
+      expect(@deployer.commands.grep(/bundle _.*_ install/)).to be_empty
     end
 
     it "still runs the hooks" do
-      deploy_dir.join('current', 'before_bundle.ran' ).should exist
-      deploy_dir.join('current', 'after_bundle.ran' ).should exist
+      expect(deploy_dir.join('current', 'before_bundle.ran' )).to exist
+      expect(deploy_dir.join('current', 'after_bundle.ran' )).to exist
     end
   end
 
@@ -80,45 +80,45 @@ describe "Deploying an application that uses Bundler" do
     before(:all) do
       deploy_test_application('no_gemfile_lock')
       @install_bundler_command = @deployer.commands.grep(/gem install bundler/).first
-      @bundle_install_command  = @deployer.commands.grep(/bundle _#{version_pattern}_ install/).first
+      @bundle_install_command  = @deployer.commands.grep(/bundle _#{VERSION_PATTERN}_ install/).first
     end
 
     it "installs the proper Bundler version" do
-      @install_bundler_command.should_not be_nil
-      @install_bundler_command.should =~ /unset RUBYOPT && gem list bundler | grep "bundler " | egrep -q "#{version_pattern}[,)]" || gem install bundler -q --no-rdoc --no-ri -v "#{version_pattern}"/
+      expect(@install_bundler_command).not_to be_nil
+      expect(@install_bundler_command).to match(/unset RUBYOPT && gem list bundler | grep "bundler " | egrep -q "#{VERSION_PATTERN}[,)]" || gem install bundler -q --no-rdoc --no-ri -v "#{VERSION_PATTERN}"/)
     end
 
     it "runs 'bundle install' without --deployment" do
-      @bundle_install_command.should_not be_nil
-      @bundle_install_command.should_not =~ /--deployment/
+      expect(@bundle_install_command).not_to be_nil
+      expect(@bundle_install_command).not_to match(/--deployment/)
     end
 
     it "exports GIT_SSH for the bundle install" do
-      @bundle_install_command.should =~ /export GIT_SSH/
+      expect(@bundle_install_command).to match(/export GIT_SSH/)
     end
 
     it "puts down RUBY_VERSION and SYSTEM_VERSION" do
-      deploy_dir.join('shared', 'bundled_gems', 'RUBY_VERSION').should exist
-      deploy_dir.join('shared', 'bundled_gems', 'SYSTEM_VERSION').should exist
+      expect(deploy_dir.join('shared', 'bundled_gems', 'RUBY_VERSION')).to exist
+      expect(deploy_dir.join('shared', 'bundled_gems', 'SYSTEM_VERSION')).to exist
     end
 
     it "warns that using a lockfile is idiomatic" do
       out = read_output
-      out.should =~ %r(WARNING: Gemfile found but Gemfile.lock is missing!)
+      expect(out).to match(/WARNING: Gemfile found but Gemfile.lock is missing!/)
     end
   end
 
   context "without a Gemfile.lock and ignoring the warning" do
     before(:all) do
       deploy_test_application('no_gemfile_lock', 'config' => {'ignore_gemfile_lock_warning' => true})
-      @config.ignore_gemfile_lock_warning.should be_true
+      expect(@config.ignore_gemfile_lock_warning).to be_true
       @install_bundler_command = @deployer.commands.grep(/gem install bundler/).first
-      @bundle_install_command  = @deployer.commands.grep(/bundle _#{version_pattern}_ install/).first
+      @bundle_install_command  = @deployer.commands.grep(/bundle _#{VERSION_PATTERN}_ install/).first
     end
 
     it "should not warn" do
       out = read_output
-      out.should_not =~ %r(WARNING)
+      expect(out).not_to match(/WARNING/)
     end
   end
 
@@ -132,8 +132,8 @@ describe "Deploying an application that uses Bundler" do
 
     it "prints the failure to the log" do
       out = read_output
-      out.should =~ %r|bundle install failure|
-      deploy_dir.join('current', 'after_bundle.ran' ).should_not exist
+      expect(out).to match(%r|bundle install failure|)
+      expect(deploy_dir.join('current', 'after_bundle.ran' )).not_to exist
     end
   end
 end

data/spec/configuration_spec.rb

@@ -9,31 +9,31 @@ describe EY::Serverside::Deploy::Configuration do
         'account_name' => 'acc',
         'framework_env' => 'production',
       })
-      @config.app_name.should == "app_name"
-      @config.environment_name.should == "env_name"
-      @config.account_name.should == "acc"
-      @config.migrate.should == nil
-      @config.migrate?.should == false
-      @config.branch.should == "master"
-      @config.maintenance_on_migrate.should == true
-      @config.maintenance_on_restart.should == true
-      @config.required_downtime_stack?.should == true
-      @config.framework_env.should == "production"
-      @config.precompile_assets.should == "detect"
-      @config.precompile_assets_inferred?.should == true
-      @config.skip_precompile_assets?.should == false
-      @config.precompile_assets?.should == false
-      @config.asset_roles.should == [:app_master, :app, :solo]
-      @config.user.should == ENV['USER']
-      @config.group.should == ENV['USER']
-      @config.verbose.should == false
-      @config.copy_exclude.should == []
-      @config.ignore_database_adapter_warning.should == false
-      @config.ignore_gemfile_lock_warning.should == false
-      @config.bundle_without.should == %w[test development]
-      @config.extra_bundle_install_options.should == %w[--without test development]
-      @config.deployed_by.should == "Automation (User name not available)"
-      @config.input_ref.should == @config.branch
+      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.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)
     end
 
     it "raises when required options are not given" do
@@ -57,7 +57,7 @@ describe EY::Serverside::Deploy::Configuration do
       capture do # deprecation warning
         expect(@config.source(test_shell)).to be_a_kind_of(EY::Serverside::Source::IntegrationSpec)
       end
-      read_output.should include("DEPRECATION WARNING: The configuration key 'strategy' is deprecated in favor of 'source_class'.")
+      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
@@ -98,28 +98,28 @@ describe EY::Serverside::Deploy::Configuration do
     end
 
     it "underrides options with config (directly supplied options take precedence over 'config' options)" do
-      @config.maintenance_on_migrate.should == false
-      @config.branch.should == "branch_from_command_line"
+      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
-      @config.skip_precompile_assets?.should == true
-      @config.precompile_assets?.should == false
-      @config.precompile_assets_inferred?.should == false
+      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
-      @config.maintenance_on_migrate.should == false
-      @config.maintenance_on_restart.should == false
+      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
-      @config.bundle_without.should == %w[test]
+      expect(@config.bundle_without).to eq(%w[test])
     end
 
     it "gets deployed_by and input_ref correct" do
-      @config.deployed_by.should == "Martin Emde"
-      @config.input_ref.should == "input_branch"
+      expect(@config.deployed_by).to eq("Martin Emde")
+      expect(@config.input_ref).to eq("input_branch")
     end
   end
 
@@ -166,37 +166,37 @@ describe EY::Serverside::Deploy::Configuration do
     it "requires 'ey.yml' and adds any defined methods to the deploy" do
       write_ey_yml 'ey.yml', @yaml_data
       @deploy.load_ey_yml
-      @deploy.config.copy_exclude.should == ['.git']
+      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
-      @deploy.config.copy_exclude.should == ['.git']
+      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
-      @deploy.config.migrate?.should == false
+      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
-      @deploy.config.branch.should == 'branch_from_command_line'
+      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
-      @deploy.config.bundle_without.should == 'only test'
+      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
-      @deploy.config.should_not be_maintenance_on_migrate
+      expect(@deploy.config).not_to be_maintenance_on_migrate
     end
   end
 end