engineyard-serverside 2.3.9 → 2.4.0

data/spec/fixtures/repos/executable_hooks/README

@@ -0,0 +1 @@
+Use an executable file for a hook, not a ruby one that uses the hook API.

data/spec/fixtures/repos/executable_hooks/deploy/before_restart

@@ -0,0 +1,72 @@
+#!/bin/sh
+
+_TEST_NUMBER=1
+_FAILED=0
+
+run_tests() {
+  local _env_var
+
+  expect_env EY_DEPLOY_ACCOUNT_NAME acc
+  expect_env EY_DEPLOY_APP rails31
+  expect_env EY_DEPLOY_ENVIRONMENT_NAME env
+  expect_env EY_DEPLOY_FRAMEWORK_ENV staging
+  expect_env MERB_ENV staging
+  expect_env NODE_ENV staging
+  expect_env RACK_ENV staging
+  expect_env RAILS_ENV staging
+  for _env_var in EY_DEPLOY_CONFIG EY_DEPLOY_RELEASE_PATH EY_DEPLOY_VERBOSE; do
+    expect_env ${_env_var}
+  done
+
+  check_working_directory ${EY_DEPLOY_RELEASE_PATH}
+}
+
+ok() {
+  echo "ok ${_TEST_NUMBER} $*"
+  _TEST_NUMBER=$((${_TEST_NUMBER} + 1))
+}
+
+not_ok() {
+  echo "not ok ${_TEST_NUMBER} $*"
+  _FAILED=1
+  _TEST_NUMBER=$((${_TEST_NUMBER} + 1))
+}
+
+check_working_directory() {
+  local _dir=$1
+
+  if [ $(pwd) = ${_dir} ]; then
+    ok "Working directory is correct"
+  else
+    not_ok "Working directory is correct"
+  fi
+}
+
+expect_env() {
+  local _name=$1
+  local _value=${2:-}
+  local _var
+  local _test_name
+
+  _test_name="ENV[${_name}]"
+  if [ -n "${_value}" ]; then
+    _test_name="${_test_name}=${_value}"
+  else
+    _test_name="${_test_name} should be set"
+  fi
+
+  eval "_var=\$${_name}"
+  if [ -n "${_var}" ]; then
+    if [ -n "${_value}" -a "${_var}" != "${_value}" ]; then
+      not_ok ${_test_name}
+    else
+      ok ${_test_name}
+    fi
+  else
+    not_ok ${_test_name}
+  fi
+}
+
+run_tests
+touch 'before_restart.ran'
+exit ${_FAILED}

data/spec/fixtures/repos/public_system/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'ey_config'

data/spec/fixtures/repos/public_system/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ey_config (0.0.5)
+    rake (0.9.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ey_config
+  rake

data/spec/fixtures/repos/public_system/README

@@ -0,0 +1,5 @@
+This is a simple bundled fake app for specs.
+
+All the files in this directory are copied into a temporary git repository
+during spec runs. The rest of the "git repository" stuff comes from
+gitrepo.tar.gz which is copied first to create the repo.

data/spec/fixtures/repos/public_system/ey.yml

@@ -0,0 +1,3 @@
+environments:
+  env:
+    ignore_database_adapter_warning: true

data/spec/fixtures/repos/public_system/public/system/cant_touch_this.txt

@@ -0,0 +1,3 @@
+This file should not be removed by serverside during a deploy.
+
+If public/system exists in the repository, leave it alone and warn.

data/spec/lockfile_parser_spec.rb

@@ -14,72 +14,72 @@ describe "the bundler version retrieved from the lockfile" do
   end
 
   it "raises an error with pre 0.9 bundler lockfiles" do
-    lambda { get_version('0.9-no-bundler')   }.should raise_error(RuntimeError, /Malformed or pre bundler-1.0.0 Gemfile.lock/)
-    lambda { get_version('0.9-with-bundler') }.should raise_error(RuntimeError, /Malformed or pre bundler-1.0.0 Gemfile.lock/)
+    expect { get_version('0.9-no-bundler')   }.to raise_error(RuntimeError, /Malformed or pre bundler-1.0.0 Gemfile.lock/)
+    expect { get_version('0.9-with-bundler') }.to raise_error(RuntimeError, /Malformed or pre bundler-1.0.0 Gemfile.lock/)
   end
 
   it "has a default version" do
-    EY::Serverside::DependencyManager::Bundler.default_version.should_not be_nil
-    EY::Serverside::DependencyManager::Bundler::DEFAULT_VERSION.should_not be_nil
+    expect(EY::Serverside::DependencyManager::Bundler.default_version).not_to be_nil
+    expect(EY::Serverside::DependencyManager::Bundler::DEFAULT_VERSION).not_to be_nil
   end
 
   it "returns the default version for a 1.0 lockfile without a bundler dependency" do
-    get_version('1.0-no-bundler').should == EY::Serverside::DependencyManager::Bundler.default_version
+    expect(get_version('1.0-no-bundler')).to eq(EY::Serverside::DependencyManager::Bundler.default_version)
   end
 
   it "gets the version from a 1.0.0.rc.1 lockfile w/dependency on 1.0.0.rc.1" do
-    get_version('1.0.0.rc.1-with-bundler').should == '1.0.0.rc.1'
+    expect(get_version('1.0.0.rc.1-with-bundler')).to eq('1.0.0.rc.1')
   end
 
   it "gets the version from a 1.0.6 lockfile w/dependency on 1.0.6" do
-    get_version('1.0.6-with-bundler').should == '1.0.6'
+    expect(get_version('1.0.6-with-bundler')).to eq('1.0.6')
   end
 
   it "gets the version from a 1.0.6 lockfile w/dependency on 1.0.6 (bundled ~> 1.0.0)" do
-    get_version('1.0.6-with-any-bundler').should == '1.0.6'
+    expect(get_version('1.0.6-with-any-bundler')).to eq('1.0.6')
   end
 
   it "gets the version from a 1.0.6 lockfile w/o dependency" do
-    get_version('1.0.6-no-bundler').should == '1.0.6'
+    expect(get_version('1.0.6-no-bundler')).to eq('1.0.6')
   end
 
   it "raises an error if it can't parse the file" do
-    lambda { get_version('not-a-lockfile') }.should raise_error(RuntimeError, /Malformed or pre bundler-1.0.0 Gemfile.lock/)
+    expect { get_version('not-a-lockfile') }.to raise_error(RuntimeError, /Malformed or pre bundler-1.0.0 Gemfile.lock/)
   end
 
   context "rails version" do
     it "retrieves rails version" do
-      get_parser('1.3.1-rails-3.2.13').rails_version.should == "3.2.13"
+      expect(get_parser('1.3.1-rails-3.2.13').rails_version).to eq("3.2.13")
     end
 
     it "finds no rails version" do
-      get_parser('1.0.18-mysql2').rails_version.should == nil
+      expect(get_parser('1.0.18-mysql2').rails_version).to eq(nil)
     end
   end
 
   context "checking for gems in the dependencies" do
     it "does not have any database adapters in a gemfile lock without them" do
-      get_parser('1.0.6-no-bundler').any_database_adapter?.should be_false
+      expect(get_parser('1.0.6-no-bundler').any_database_adapter?).to be_false
     end
 
     it "has a database adapter in a Gemfile.lock with do_mysql" do
-      get_parser('1.0.18-do_mysql').any_database_adapter?.should be_true
+      expect(get_parser('1.0.18-do_mysql').any_database_adapter?).to be_true
     end
 
     it "has a database adapter in a Gemfile.lock with mysql" do
-      get_parser('1.0.18-mysql').any_database_adapter?.should be_true
+      expect(get_parser('1.0.18-mysql').any_database_adapter?).to be_true
     end
 
     it "has a database adapter in a Gemfile.lock with mysql2" do
-      get_parser('1.0.18-mysql2').any_database_adapter?.should be_true
+      expect(get_parser('1.0.18-mysql2').any_database_adapter?).to be_true
     end
 
     it "has a database adapter in a Gemfile.lock with pg" do
-      get_parser('1.0.18-pg').any_database_adapter?.should be_true
+      expect(get_parser('1.0.18-pg').any_database_adapter?).to be_true
     end
 
     it "has a database adapter in a Gemfile.lock with do_postgres" do
-      get_parser('1.0.18-do_postgres').any_database_adapter?.should be_true
+      expect(get_parser('1.0.18-do_postgres').any_database_adapter?).to be_true
     end
   end
 
@@ -87,36 +87,36 @@ describe "the bundler version retrieved from the lockfile" do
     subject { get_parser('1.0.6-no-bundler') }
 
     it "uses the default version when there is no bundler version" do
-      subject.fetch_version(nil, nil).should == EY::Serverside::DependencyManager::Bundler.default_version
+      expect(subject.fetch_version(nil, nil)).to eq(EY::Serverside::DependencyManager::Bundler.default_version)
     end
 
     it "uses the given version when there is no operator" do
-      subject.fetch_version(nil, '1.0.1').should == '1.0.1'
+      expect(subject.fetch_version(nil, '1.0.1')).to eq('1.0.1')
     end
 
     it "uses the given version when the qualifier is `='" do
-      subject.fetch_version('=', '1.0.1').should == '1.0.1'
+      expect(subject.fetch_version('=', '1.0.1')).to eq('1.0.1')
     end
 
     it "uses the default version when we get a pessimistic qualifier and is lower than the default version" do
-      subject.fetch_version('~>', '1.3.1').should == EY::Serverside::DependencyManager::Bundler.default_version
+      expect(subject.fetch_version('~>', '1.3.1')).to eq(EY::Serverside::DependencyManager::Bundler.default_version)
     end
 
     it "uses the given version when we get a pessimistic qualifier that doesn't match the default version" do
-      subject.fetch_version('~>', '1.0.0').should == '1.0.0'
+      expect(subject.fetch_version('~>', '1.0.0')).to eq('1.0.0')
     end
 
     it "uses the given version when it's geater of equal than the default version" do
-      subject.fetch_version('>=', '1.100.0').should == '1.100.0'
+      expect(subject.fetch_version('>=', '1.100.0')).to eq('1.100.0')
     end
 
     it "uses the default version when the given version is lower" do
-      subject.fetch_version('>=', '1.0.1').should == EY::Serverside::DependencyManager::Bundler.default_version
+      expect(subject.fetch_version('>=', '1.0.1')).to eq(EY::Serverside::DependencyManager::Bundler.default_version)
     end
 
     it "selects only the first version expression" do
       scan = subject.scan_gem('bundler', 'bundler (>=1.0.1, <2.0.0)')
-      scan.last.should == '1.0.1'
+      expect(scan.last).to eq('1.0.1')
     end
   end
 end

data/spec/multi_dependency_manager_spec.rb

@@ -12,13 +12,13 @@ describe "Deploying an application that uses Node.js and NPM" do
 
       it "runs 'npm install' and 'composer install'" do
         npm_cmd = @deployer.commands.grep(/npm install/).first
-        npm_cmd.should_not be_nil
+        expect(npm_cmd).not_to be_nil
 
         update_cmd = @deployer.commands.grep(/composer.*self-update/).first
-        update_cmd.should_not be_nil
+        expect(update_cmd).not_to be_nil
 
         composer_cmd = @deployer.commands.grep(/composer install/).first
-        composer_cmd.should_not be_nil
+        expect(composer_cmd).not_to be_nil
       end
     end
   end

data/spec/nodejs_deploy_spec.rb

@@ -13,7 +13,7 @@ describe "Deploying an application that uses Node.js and NPM" do
 
       it "runs 'npm install'" do
         install_cmd = @deployer.commands.grep(/npm install/).first
-        install_cmd.should_not be_nil
+        expect(install_cmd).not_to be_nil
       end
     end
 
@@ -23,7 +23,7 @@ describe "Deploying an application that uses Node.js and NPM" do
       end
 
       it "does not run 'npm install'" do
-        @deployer.commands.grep(/npm/).should be_empty
+        expect(@deployer.commands.grep(/npm/)).to be_empty
       end
     end
   end

data/spec/php_deploy_spec.rb

@@ -13,7 +13,7 @@ describe "Deploying an application that uses PHP and Composer" do
 
         it "runs 'composer install'" do
           install_cmd = @deployer.commands.grep(/composer install/).first
-          install_cmd.should_not be_nil
+          expect(install_cmd).not_to be_nil
         end
 
         it "attempts to run 'composer self-update' before 'composer install'" do
@@ -21,7 +21,7 @@ describe "Deploying an application that uses PHP and Composer" do
           @deployer.commands.each do |cmd|
             update_cmd ||= /composer.*self-update/.match(cmd)
             if /composer install/.match(cmd)
-              update_cmd.should_not be nil
+              expect(update_cmd).not_to be nil
             end
           end
         end
@@ -33,7 +33,7 @@ describe "Deploying an application that uses PHP and Composer" do
         end
 
         it "does not run composer" do
-          @deployer.commands.grep(/composer/).should be_empty
+          expect(@deployer.commands.grep(/composer/)).to be_empty
         end
       end
 
@@ -43,13 +43,13 @@ describe "Deploying an application that uses PHP and Composer" do
         end
 
         it "outputs a warning about deploying without a .lock" do
-          warning_out = read_output.should include("WARNING: composer.json found but composer.lock missing!")
-          warning_out.should_not be_nil
+          warning_out = expect(read_output).to include("WARNING: composer.json found but composer.lock missing!")
+          expect(warning_out).not_to be_nil
         end
 
         it "runs 'composer install'" do
           install_cmd = @deployer.commands.grep(/composer install/).first
-          install_cmd.should_not be_nil
+          expect(install_cmd).not_to be_nil
         end
 
         it "attempts to run 'composer self-update' before 'composer install'" do
@@ -57,7 +57,7 @@ describe "Deploying an application that uses PHP and Composer" do
           @deployer.commands.each do |cmd|
             update_cmd ||= /composer.*self-update/.match(cmd)
             if /composer install/.match(cmd)
-              update_cmd.should_not be nil
+              expect(update_cmd).not_to be nil
             end
           end
         end

data/spec/rails31_deploy_spec.rb

@@ -4,73 +4,73 @@ describe "Deploying a Rails 3.1 application" do
   context "with default production settings" do
     it "precompiles assets when asset compilation is detected" do
       deploy_test_application('assets_detected')
-      deploy_dir.join('current', 'precompiled').should exist
-      deploy_dir.join('current', 'public', 'assets').should exist
-      deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should exist
-      read_output.should include("Precompiling assets. ('app/assets' exists, 'public/assets' not found, not disabled in config.)")
+      expect(deploy_dir.join('current', 'precompiled')).to exist
+      expect(deploy_dir.join('current', 'public', 'assets')).to exist
+      expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).to exist
+      expect(read_output).to include("Precompiling assets. ('app/assets' exists, 'public/assets' not found, not disabled in config.)")
     end
 
     it "precompiles assets, then reuses them on the next deploy if nothing has changed" do
       deploy_test_application('assets_enabled_in_ey_yml')
-      deploy_dir.join('current', 'precompiled').should exist
-      deploy_dir.join('current', 'public', 'assets').should exist
-      deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should exist
+      expect(deploy_dir.join('current', 'precompiled')).to exist
+      expect(deploy_dir.join('current', 'public', 'assets')).to exist
+      expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).to exist
 
       redeploy_test_application
-      deploy_dir.join('current', 'precompiled').should_not exist # doesn't run the task
-      deploy_dir.join('current', 'public', 'assets').should exist # but the assets are there
-      deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should exist
-      read_output.should =~ %r#Reusing existing assets\. \(configured asset_dependencies unchanged from \w{7}..\w{7}\)#
+      expect(deploy_dir.join('current', 'precompiled')).not_to exist # doesn't run the task
+      expect(deploy_dir.join('current', 'public', 'assets')).to exist # but the assets are there
+      expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).to exist
+      expect(read_output).to match(%r#Reusing existing assets\. \(configured asset_dependencies unchanged from \w{7}..\w{7}\)#)
 
       redeploy_test_application('config' => {'precompile_unchanged_assets' => 'true'})
-      deploy_dir.join('current', 'precompiled').should exist # doesn't run the task
-      deploy_dir.join('current', 'public', 'assets').should exist # but the assets are there
-      deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should exist
-      read_output.should_not include("Reusing existing assets")
+      expect(deploy_dir.join('current', 'precompiled')).to exist # doesn't run the task
+      expect(deploy_dir.join('current', 'public', 'assets')).to exist # but the assets are there
+      expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).to exist
+      expect(read_output).not_to include("Reusing existing assets")
     end
 
     it "precompile assets again when redeploying a ref with changes" do
       deploy_test_application('assets_enabled_in_ey_yml')
-      deploy_dir.join('current', 'precompiled').should exist
-      deploy_dir.join('current', 'public', 'assets').should exist
-      deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should exist
-      read_output.should include("Precompiling assets. (precompile_assets: true)")
+      expect(deploy_dir.join('current', 'precompiled')).to exist
+      expect(deploy_dir.join('current', 'public', 'assets')).to exist
+      expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).to exist
+      expect(read_output).to include("Precompiling assets. (precompile_assets: true)")
 
       # changing the ref stands in for actually having assets change (see Strategies::IntegrationSpec#same?)
       redeploy_test_application('branch' => 'somenewref')
-      deploy_dir.join('current', 'precompiled').should exist # it does runs the task
-      deploy_dir.join('current', 'public', 'assets').should exist
-      deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should exist
-      read_output.should_not =~ %r#Reusing existing assets#
+      expect(deploy_dir.join('current', 'precompiled')).to exist # it does runs the task
+      expect(deploy_dir.join('current', 'public', 'assets')).to exist
+      expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).to exist
+      expect(read_output).not_to match(%r#Reusing existing assets#)
     end
 
     it "precompile assets when redeploying the same ref, but assets were turned off the first time" do
       deploy_test_application('assets_enabled_in_ey_yml', 'config' => {'precompile_assets' => 'false'})
-      deploy_dir.join('current', 'precompiled').should_not exist
-      deploy_dir.join('current', 'public', 'assets').should_not exist
-      deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should_not exist
-      read_output.should_not include("Precompiling assets. (precompile_assets: true)")
+      expect(deploy_dir.join('current', 'precompiled')).not_to exist
+      expect(deploy_dir.join('current', 'public', 'assets')).not_to exist
+      expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).not_to exist
+      expect(read_output).not_to include("Precompiling assets. (precompile_assets: true)")
 
       # assets will show as unchanged, but it should compile them fresh anyway.
       redeploy_test_application('config' => {'precompile_assets' => 'true'})
-      deploy_dir.join('current', 'precompiled').should exist # it does runs the task
-      deploy_dir.join('current', 'public', 'assets').should exist
-      deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should exist
-      read_output.should_not =~ %r#Reusing existing assets#
+      expect(deploy_dir.join('current', 'precompiled')).to exist # it does runs the task
+      expect(deploy_dir.join('current', 'public', 'assets')).to exist
+      expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).to exist
+      expect(read_output).not_to match(%r#Reusing existing assets#)
     end
 
     %w[cleaning shared private].each do |strategy|
       it "precompiles assets with asset_strategy '#{strategy}', then reuses them on the next deploy if nothing has changed" do
         deploy_test_application('assets_enabled_in_ey_yml', 'config' => {'asset_strategy' => strategy})
-        deploy_dir.join('current', 'precompiled').should exist
-        deploy_dir.join('current', 'public', 'assets').should exist
-        deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should exist
+        expect(deploy_dir.join('current', 'precompiled')).to exist
+        expect(deploy_dir.join('current', 'public', 'assets')).to exist
+        expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).to exist
 
         redeploy_test_application
-        deploy_dir.join('current', 'precompiled').should_not exist # doesn't run the task
-        deploy_dir.join('current', 'public', 'assets').should exist # but the assets are there
-        deploy_dir.join('current', 'public', 'assets', 'compiled_asset').should exist
-        read_output.should =~ %r#Reusing existing assets\. \(configured asset_dependencies unchanged from \w{7}..\w{7}\)#
+        expect(deploy_dir.join('current', 'precompiled')).not_to exist # doesn't run the task
+        expect(deploy_dir.join('current', 'public', 'assets')).to exist # but the assets are there
+        expect(deploy_dir.join('current', 'public', 'assets', 'compiled_asset')).to exist
+        expect(read_output).to match(%r#Reusing existing assets\. \(configured asset_dependencies unchanged from \w{7}..\w{7}\)#)
       end
     end
   end
@@ -81,8 +81,8 @@ describe "Deploying a Rails 3.1 application" do
     end
 
     it "precompiles assets" do
-      deploy_dir.join('current', 'precompiled').should exist
-      read_output.should include("Precompiling assets. (precompile_assets: true)")
+      expect(deploy_dir.join('current', 'precompiled')).to exist
+      expect(read_output).to include("Precompiling assets. (precompile_assets: true)")
     end
   end
 
@@ -92,8 +92,8 @@ describe "Deploying a Rails 3.1 application" do
     end
 
     it "precompiles assets" do
-      deploy_dir.join('current', 'precompiled').should_not exist
-      read_output.should include("Precompiling assets. (precompile_assets: true)")
+      expect(deploy_dir.join('current', 'precompiled')).not_to exist
+      expect(read_output).to include("Precompiling assets. (precompile_assets: true)")
     end
   end
 
@@ -103,22 +103,22 @@ describe "Deploying a Rails 3.1 application" do
     end
 
     it "precompiles assets" do
-      deploy_dir.join('current', 'precompiled').should exist
-      read_output.should include("Precompiling assets. (precompile_assets: true)")
+      expect(deploy_dir.join('current', 'precompiled')).to exist
+      expect(read_output).to include("Precompiling assets. (precompile_assets: true)")
     end
   end
 
   context "with asset support disabled in config/application.rb" do
     it "does not precompile assets" do
       deploy_test_application('assets_disabled')
-      deploy_dir.join('current', 'precompiled').should_not exist
-      read_output.should include("Skipping asset precompilation. ('config/application.rb' disables assets.)")
+      expect(deploy_dir.join('current', 'precompiled')).not_to exist
+      expect(read_output).to include("Skipping asset precompilation. ('config/application.rb' disables assets.)")
     end
 
     it "deploys successfully when application.rb has utf-8 encoding" do
       deploy_test_application('assets_disabled_utf8')
-      deploy_dir.join('current', 'precompiled').should_not exist
-      read_output.should include("Skipping asset precompilation. ('config/application.rb' disables assets.)")
+      expect(deploy_dir.join('current', 'precompiled')).not_to exist
+      expect(read_output).to include("Skipping asset precompilation. ('config/application.rb' disables assets.)")
     end
   end
 
@@ -128,8 +128,8 @@ describe "Deploying a Rails 3.1 application" do
     end
 
     it "does not precompile assets" do
-      deploy_dir.join('current', 'precompiled').should_not exist
-      read_output.should include("Skipping asset precompilation. (precompile_assets: false)")
+      expect(deploy_dir.join('current', 'precompiled')).not_to exist
+      expect(read_output).to include("Skipping asset precompilation. (precompile_assets: false)")
     end
   end
 
@@ -139,12 +139,12 @@ describe "Deploying a Rails 3.1 application" do
     end
 
     it "does not replace the public/assets directory" do
-      deploy_dir.join('current', 'custom_compiled').should exist
-      deploy_dir.join('current', 'precompiled').should_not exist
-      deploy_dir.join('current', 'public', 'assets').should be_directory
-      deploy_dir.join('current', 'public', 'assets').should_not be_symlink
-      deploy_dir.join('current', 'public', 'assets', 'custom_compiled_asset').should exist
-      read_output.should include("Skipping asset precompilation. ('public/assets' directory already exists.)")
+      expect(deploy_dir.join('current', 'custom_compiled')).to exist
+      expect(deploy_dir.join('current', 'precompiled')).not_to exist
+      expect(deploy_dir.join('current', 'public', 'assets')).to be_directory
+      expect(deploy_dir.join('current', 'public', 'assets')).not_to be_symlink
+      expect(deploy_dir.join('current', 'public', 'assets', 'custom_compiled_asset')).to exist
+      expect(read_output).to include("Skipping asset precompilation. ('public/assets' directory already exists.)")
     end
   end
 end