engineyard-serverside 1.4.9.nodestack → 1.4.11

data/lib/engineyard-serverside.rb

@@ -4,8 +4,6 @@ $LOAD_PATH.unshift File.expand_path('vendor/escape/lib', File.dirname(__FILE__))
 $LOAD_PATH.unshift File.expand_path('vendor/json_pure/lib', File.dirname(__FILE__))
 $LOAD_PATH.unshift File.expand_path('vendor/dataflow', File.dirname(__FILE__))
 
-require 'core-ext/string' if RUBY_VERSION == '1.8.6'
-
 require 'escape'
 require 'json'
 require 'dataflow'
@@ -36,7 +34,7 @@ module EY
                       {}.to_json
                     end
     end
-    
+
     RemoteFailure = Class.new StandardError
 
     private

data/lib/engineyard-serverside/cli.rb

@@ -1,6 +1,5 @@
 require 'thor'
 require 'pathname'
-require 'tmpdir'
 
 module EY
   module Serverside
@@ -215,11 +214,11 @@ module EY
       def propagate
         config          = EY::Serverside::Deploy::Configuration.new
         gem_filename    = "engineyard-serverside-#{EY::Serverside::VERSION}.gem"
-        local_gem_file  = File.join(::Gem.dir, 'cache', gem_filename)
+        local_gem_file  = File.join(Gem.dir, 'cache', gem_filename)
         remote_gem_file = File.join(Dir.tmpdir, gem_filename)
-        gem_binary      = File.join(::Gem.default_bindir, 'gem')
+        gem_binary      = File.join(Gem.default_bindir, 'gem')
 
-        EY::Serverside::Server.all.find_all do |server|
+        barrier(*(EY::Serverside::Server.all.find_all do |server|
           !server.local?            # of course this machine has it
         end.map do |server|
           need_later do
@@ -240,7 +239,7 @@ module EY
               server.run("sudo #{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'")
             end
           end
-        end
+        end))
       end
 
       private

data/lib/engineyard-serverside/configuration.rb

@@ -119,7 +119,7 @@ module EY
       end
 
       def framework_envs
-        "RAILS_ENV=#{environment} RACK_ENV=#{environment} NODE_ENV=#{environment} MERB_ENV=#{environment}"
+        "RAILS_ENV=#{environment} RACK_ENV=#{environment} MERB_ENV=#{environment}"
       end
 
       def current_path

data/lib/engineyard-serverside/deploy.rb

@@ -27,7 +27,6 @@ module EY
           create_revision_file
           run_with_callbacks(:bundle)
           symlink_configs
-          generate_configs
           conditionally_enable_maintenance_page
           run_with_callbacks(:migrate)
           callback(:before_symlink)
@@ -137,12 +136,11 @@ module EY
           bundler_installer = if File.exist?(lockfile)
                                 get_bundler_installer(lockfile)
                               else
-                                missing_lock_version = EY::Serverside::LockfileParser::Parse10::DEFAULT
-                                warn_about_missing_lockfile missing_lock_version
-                                bundler_10_installer missing_lock_version
+                                warn_about_missing_lockfile
+                                bundler_09_installer(default_09_bundler)
                               end
 
-          sudo "#{$0} _#{EY::Serverside::VERSION}_ install_bundler #{bundler_installer.version}"
+          sudo "#{serverside_bin} install_bundler #{bundler_installer.version}"
 
           bundled_gems_path = File.join(c.shared_path, "bundled_gems")
           ruby_version_file = File.join(bundled_gems_path, "RUBY_VERSION")
@@ -166,15 +164,6 @@ module EY
 
           run "mkdir -p #{bundled_gems_path} && ruby -v > #{ruby_version_file} && uname -m > #{system_version_file}"
         end
-
-        if File.exist?("#{c.release_path}/package.json")
-          unless run("which npm")
-            error "~> package.json detected, BUT npm not installed"
-          else
-            info "~> package.json detected, installing npm packages"
-            run "cd #{c.release_path} && npm install"
-          end
-        end
       end
 
       # task
@@ -229,7 +218,6 @@ module EY
         run create_revision_file_command
       end
 
-      # symlink to shared path; may be overridden by #generate_configs
       def symlink_configs(release_to_link=c.release_path)
         info "~> Symlinking configs"
         [ "chmod -R g+w #{release_to_link}",
@@ -240,8 +228,8 @@ module EY
           "mkdir -p #{release_to_link}/config",
           "ln -nfs #{c.shared_path}/system #{release_to_link}/public/system",
           "ln -nfs #{c.shared_path}/pids #{release_to_link}/tmp/pids",
-          "find #{c.shared_path}/config ! -name 'database.yml*' -type f -exec ln -s {} #{release_to_link}/config \\;",
-          # database.yml generated or symlink created in #generate_database_yml
+          "find #{c.shared_path}/config -type f -exec ln -s {} #{release_to_link}/config \\;",
+          "ln -nfs #{c.shared_path}/config/database.yml #{release_to_link}/config/database.yml",
           "ln -nfs #{c.shared_path}/config/mongrel_cluster.yml #{release_to_link}/config/mongrel_cluster.yml",
         ].each do |cmd|
           run cmd
@@ -251,84 +239,6 @@ module EY
         run "if [ -f \"#{c.shared_path}/config/newrelic.yml\" ]; then ln -nfs #{c.shared_path}/config/newrelic.yml #{release_to_link}/config/newrelic.yml; fi"
       end
 
-      def generate_configs(release_to_link=c.release_path)
-        generate_database_yml(release_to_link)
-      end
-
-      # Do nothing if there is no Gemfile.lock to determine what ORM gems are being used
-      # (falls back to using the symlinked shared/database.yml file)
-      def generate_database_yml(release_to_link)
-        return if keep_database_yml?(release_to_link)
-        if config["db_adapter"] || File.exist?("#{c.release_path}/Gemfile.lock")
-          info "~> Generating database.yml from Gemfile.lock"
-          database_yml = "#{release_to_link}/config/database.yml"
-          node         = EY::Serverside.node
-          node_app     = node["engineyard"]["environment"]["apps"].find { |app| app['name'] == c['app'] }
-          abort("Invalid application name for target environment: #{c['app']}") unless node_app
-
-          db_stack_name   = node[:engineyard][:environment][:db_stack_name]
-          instances       = node[:engineyard][:environment][:instances]
-          db_master       = {"public_hostname" => "localhost"} # you know, just in case
-          db_slaves       = []
-          instances.each do |i|
-            case i['role']
-            when 'db_master', 'solo'
-              db_master = i
-            when 'db_slave'
-              db_slaves << i
-            end
-          end
-          db_host         = db_master["public_hostname"]
-          db_slaves_hosts = db_slaves.map {|slave| slave["public_hostname"]}
-
-          if config["db_adapter"]
-            adapter = config["db_adapter"]
-          elsif bundler_gems_include?("mysql2")
-            adapter = "mysql2"
-          elsif bundler_gems_include?("mysql")
-            adapter = "mysql"
-          elsif bundler_gems_include?("pg")
-            adapter = "postgresql"
-          elsif bundler_gems_include?("jdbc-mysql")
-            adapter = "mysql"
-          elsif bundler_gems_include?("jdbc-postgres")
-            adapter = "postgresql"
-          elsif db_stack_name && db_stack_name =~ /postgres/
-            adapter = "postgresql"
-          else
-            adapter = "mysql"
-          end
-
-          File.open(database_yml, "w") do |file|
-            contents = <<-EOS.gsub(/^\s{12}/, '')
-            #{node[:engineyard][:environment][:framework_env]}:
-              adapter:   #{adapter}
-              database:  #{node_app[:database_name]}
-              username:  #{node[:engineyard][:environment][:ssh_username]}
-              password:  #{node[:engineyard][:environment][:ssh_password]}
-              host:      #{db_host}
-              reconnect: true
-            EOS
-            db_slaves_hosts.each_with_index do |host, n|
-              slave_name = n.zero? ? "slave" : "slave_#{n}"
-              contents << <<-EOS.gsub(/^\s{14}/, '')
-              #{slave_name}:
-                adapter:   #{adapter}
-                database:  #{node_app[:database_name]}
-                username:  #{node[:engineyard][:environment][:ssh_username]}
-                password:  #{node[:engineyard][:environment][:ssh_password]}
-                host:      #{host}
-                reconnect: true
-              EOS
-            end
-            file << contents
-          end
-        else
-          info "~> Symlinking database.yml config"
-          run "ln -nfs #{c.shared_path}/config/database.yml #{release_to_link}/config/database.yml"
-        end
-      end
-
       # task
       def symlink(release_to_link=c.release_path)
         info "~> Symlinking code"
@@ -357,18 +267,18 @@ module EY
       protected
 
       def base_callback_command_for(what)
-        [$0, version_specifier, 'hook', what.to_s,
+        [serverside_bin, 'hook', what.to_s,
           '--app', config.app.to_s,
           '--release-path', config.release_path.to_s,
           '--framework-env', c.environment.to_s,
         ].compact
       end
 
-      def version_specifier
-        "_#{EY::Serverside::VERSION}_"
+      def serverside_bin
+        basedir = File.expand_path('../../..', __FILE__)
+        File.join(basedir, 'bin', 'engineyard-serverside')
       end
 
-
       def puts_deploy_failure
         if @cleanup_failed
           info "~> [Relax] Your site is running new code, but cleaning up old deploys failed"
@@ -400,7 +310,7 @@ module EY
         raise
       end
 
-      def warn_about_missing_lockfile(missing_lock_version)
+      def warn_about_missing_lockfile
         info "!>"
         info "!> WARNING: Gemfile.lock is missing!"
         info "!> You can get different gems in production than what you tested with."
@@ -410,52 +320,30 @@ module EY
         info "!> Fix this by running \"git add Gemfile.lock; git commit\" and deploying again."
         info "!> If you don't have a Gemfile.lock, run \"bundle lock\" to create one."
         info "!>"
-        info "!> This deployment will use bundler #{missing_lock_version} to run 'bundle install'."
+        info "!> This deployment will use bundler #{default_09_bundler} to run 'bundle install'."
         info "!>"
       end
 
-      def keep_database_yml?(release_to_link=c.release_path)
-        File.exists?(File.join(release_to_link, "config", "keep.database.yml"))
-      end
-
-      # returns true if "bundle list" includes all gems requested
-      def bundler_gems_include?(*gems)
-        lockfile = File.join(c.release_path, "Gemfile.lock")
-        @lockfile_contents ||= File.read(lockfile)
-
-        # Parsing Gemfile.lock which looks like
-        # GEM
-        #   remote: http://rubygems.org/
-        #   specs:
-        #     activemodel (3.0.10)
-        #       activesupport (= 3.0.10)
-        #       builder (~> 2.1.2)
-        #       i18n (~> 0.5.0)
-        #
-        gems.inject(true) {|found_all, gem| found_all && (@lockfile_contents =~ / #{gem} \(/)}
-      end
-
-      def get_bundler_installer(lockfile, options = '')
+      def get_bundler_installer(lockfile)
         parser = LockfileParser.new(File.read(lockfile))
         case parser.lockfile_version
         when :bundler09
-          bundler_09_installer(parser.bundler_version, options)
+          bundler_09_installer(parser.bundler_version)
         when :bundler10
-          bundler_10_installer(parser.bundler_version, options)
+          bundler_10_installer(parser.bundler_version)
         else
           raise "Unknown lockfile version #{parser.lockfile_version}"
         end
       end
       public :get_bundler_installer
 
-      def bundler_09_installer(version, options = '')
-        default_options = '--without=development --without=test'
-        BundleInstaller.new(version, default_options + options)
+      def bundler_09_installer(version)
+        BundleInstaller.new(version, '--without=development --without=test')
       end
 
-      def bundler_10_installer(version, options = '')
-        default_options = "--deployment --path #{c.shared_path}/bundled_gems --binstubs #{c.binstubs_path} --without development test"
-        BundleInstaller.new(version, default_options + options)
+      def bundler_10_installer(version)
+        BundleInstaller.new(version,
+          "--deployment --path #{c.shared_path}/bundled_gems --binstubs #{c.binstubs_path} --without development test")
       end
     end   # DeployBase
 

data/lib/engineyard-serverside/lockfile_parser.rb

@@ -79,11 +79,13 @@ module EY
           when '='
             bundler_version
           when '>='
-            ::Gem::Version.new(bundler_version) > ::Gem::Version.new(DEFAULT) ? bundler_version : DEFAULT
+            Gem::Version.new(bundler_version) > Gem::Version.new(DEFAULT) ? bundler_version : DEFAULT
           when '~>'
-            bundler_gem_version = ::Gem::Version.new(bundler_version)
+            bundler_gem_version = Gem::Version.new(bundler_version)
             recommendation = bundler_gem_version.spermy_recommendation.gsub(/~>\s*(.+)$/, '\1.')
-            DEFAULT.start_with?(recommendation) && ::Gem::Version.new(DEFAULT) > bundler_gem_version ? DEFAULT : bundler_version
+            recommends_default = DEFAULT.index(recommendation) == 0
+            default_newer_than_requested = Gem::Version.new(DEFAULT) > bundler_gem_version
+            (recommends_default && default_newer_than_requested) ? DEFAULT : bundler_version
           end
         end
 

data/lib/engineyard-serverside/logged_output.rb

@@ -41,11 +41,6 @@ module EY
         EY::Serverside::LoggedOutput.verbose?
       end
 
-      # TODO color output
-      def error(msg)
-        info(msg)
-      end
-
       def info(msg)
         with_logfile do |log|
           Tee.new($stdout, log) << (msg + "\n")

data/lib/engineyard-serverside/task.rb

@@ -54,7 +54,6 @@ module EY
           need_later { server.run(Escape.shell_command(wrapper + [to_run])) }
         end
         barrier *results
-
         # MRI's truthiness check is an internal C thing that does not call
         # any methods... so Dataflow cannot proxy it & we must "x == true"
         # Rubinius, wherefore art thou!?

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '1.4.9.nodestack'
+    VERSION = '1.4.11'
   end
 end

data/spec/custom_deploy_spec.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/spec_helper'
-require 'fileutils'
 
 describe "the EY::Serverside::Deploy API" do
   it "calls tasks in the right order" do
@@ -30,12 +29,9 @@ describe "the EY::Serverside::Deploy API" do
       def cleanup_old_releases()                   @call_order << 'cleanup_old_releases'                   end
       def conditionally_enable_maintenance_page()  @call_order << 'conditionally_enable_maintenance_page'  end
       def disable_maintenance_page()               @call_order << 'disable_maintenance_page'               end
-      def generate_database_yml(path)              @call_order << 'generate_database_yml'                  end
     end
 
-    setup_dna_json
-
-    td = TestDeploy.new(EY::Serverside::Deploy::Configuration.new('app' => 'myfirstapp'))
+    td = TestDeploy.new(EY::Serverside::Deploy::Configuration.new)
     td.deploy
     td.call_order.should == %w(
       push_code
@@ -43,7 +39,6 @@ describe "the EY::Serverside::Deploy API" do
       create_revision_file
       bundle
       symlink_configs
-      generate_database_yml
       conditionally_enable_maintenance_page
       migrate
       symlink
@@ -58,17 +53,15 @@ describe "the EY::Serverside::Deploy API" do
     end
 
     before(:each) do
-      @tempdir = File.join(Dir.tmpdir, "serverside-deploy-#{Time.now.to_i}-#{$$}")
-      @config  = EY::Serverside::Deploy::Configuration.new('repository_cache' => @tempdir)
-      @deploy  = TestQuietDeploy.new(@config)
-    end
-
-    after do
-      FileUtils.rm_rf(@tempdir)
+      @tempdir = `mktemp -d -t custom_deploy_spec.XXXXX`.strip
+      @config = EY::Serverside::Deploy::Configuration.new('repository_cache' => @tempdir)
+      @deploy = TestQuietDeploy.new(@config)
     end
 
     def write_eydeploy(relative_path, contents = "def got_new_methods() 'from the file on disk' end")
-      FileUtils.mkdir_p(File.join(@tempdir, File.dirname(relative_path)))
+      FileUtils.mkdir_p(File.join(
+          @tempdir,
+          File.dirname(relative_path)))
 
       File.open(File.join(@tempdir, relative_path), 'w') do |f|
         f.write contents

data/spec/git_strategy_spec.rb

@@ -2,10 +2,8 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe "the git deploy strategy" do
   subject do
-    EY::Serverside::Strategies::Git.new(:repo => File.expand_path("../fixtures/gitrepo/.git", __FILE__),
-                            :repository_cache => File.expand_path("../fixtures/gitrepo", __FILE__),
-                            :ref => "master"
-                            )
+    EY::Serverside::Strategies::Git.new(:repo => File.join(GITREPO_DIR, 'git'),
+                                        :repository_cache => GITREPO_DIR, :ref => "master")
   end
 
   before { subject.checkout }

data/spec/real_deploy_spec.rb

@@ -1,7 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/lib/full_test_deploy'
 
-module EY::Serverside::Strategies::DeployIntegrationSpec
+module EY::Serverside::Strategies::IntegrationSpec
   module Helpers
 
     def update_repository_cache
@@ -20,6 +19,7 @@ module EY::Serverside::Strategies::DeployIntegrationSpec
 
       FileUtils.mkdir_p(File.join(c.shared_path, 'config'))
 
+      FileUtils.mkdir_p(cached_copy)
       Dir.chdir(cached_copy) do
         `echo "this is my file; there are many like it, but this one is mine" > file`
         File.open('Gemfile', 'w') do |f|
@@ -46,21 +46,6 @@ DEPENDENCIES
   rake
 EOF
         end
-
-        File.open('package.json', 'w') do |f|
-          f.write <<-EOF
-{
-    "name": "application-name"
-  , "version": "0.0.1"
-  , "private": true
-  , "dependencies": {
-      "express": "2.3.12"
-    , "jade": ">= 0.0.1"
-  }
-}
-EOF
-        end
-
       end
     end
 
@@ -76,44 +61,125 @@ EOF
 end
 
 describe "deploying an application" do
+  class FullTestDeploy < EY::Serverside::Deploy
+    attr_reader :infos, :debugs, :commands
+
+    def initialize(*)
+      super
+      @infos = []
+      @debugs = []
+      @commands = []
+    end
+
+    # stfu
+    def info(msg)
+      @infos << msg
+    end
+
+    # no really, stfu
+    def debug(msg)
+      @debugs << msg
+    end
+
+    # passwordless sudo is neither guaranteed nor desired
+    def sudo(cmd)
+      run(cmd)
+    end
+
+    def run(cmd)
+      @commands << cmd
+      super
+    end
+
+    def version_specifier
+      # Normally, the deploy task invokes the hook task by executing
+      # the rubygems-generated wrapper (it's what's in $PATH). It
+      # specifies the version to make sure that the pieces don't get
+      # out of sync. However, in test mode, there's no
+      # rubygems-generated wrapper, and so the hook task doesn't get
+      # run because thor thinks we're trying to invoke the _$VERSION_
+      # task instead, which doesn't exist.
+      #
+      # By stripping that out, we can get the hooks to actually run
+      # inside this test.
+      nil
+    end
+
+    def restart
+      FileUtils.touch("#{c.release_path}/restart")
+    end
+
+    # we're probably running this spec under bundler, but a real
+    # deploy does not
+    def bundle
+      my_env = ENV.to_hash
+
+      ENV.delete("BUNDLE_GEMFILE")
+      ENV.delete("BUNDLE_BIN_PATH")
+
+      result = super
+
+      ENV.replace(my_env)
+      result
+    end
+
+    def get_bundler_installer(lockfile)
+      installer = super
+      installer.options << ' --quiet'   # stfu already!
+      installer
+    end
+
+  end
 
   before(:all) do
     @deploy_dir = File.join(Dir.tmpdir, "serverside-deploy-#{Time.now.to_i}-#{$$}")
-    FileUtils.mkdir_p(@deploy_dir)
 
     # set up EY::Serverside::Server like we're on a solo
     EY::Serverside::Server.reset
     EY::Serverside::Server.add(:hostname => 'localhost', :roles => %w[solo])
 
-    setup_dna_json
-
     # run a deploy
     config = EY::Serverside::Deploy::Configuration.new({
-        "strategy"      => "DeployIntegrationSpec",
+        "strategy"      => "IntegrationSpec",
         "deploy_to"     => @deploy_dir,
         "group"         => `id -gn`.strip,
         "stack"         => 'nginx_passenger',
         "migrate"       => "ruby -e 'puts ENV[\"PATH\"]' > #{@deploy_dir}/path-when-migrating",
-        'app'           => 'myfirstapp',
+        'app'           => 'foo',
         'framework_env' => 'staging'
       })
 
     # pretend there is a shared bundled_gems directory
     FileUtils.mkdir_p(File.join(@deploy_dir, 'shared', 'bundled_gems'))
-    %w(RUBY_VERSION SYSTEM_VERSION).each do |name|
+    %w(RUBY_VERSION SYSTEM_VERSION).each do |name| 
       File.open(File.join(@deploy_dir, 'shared', 'bundled_gems', name), "w") { |f| f.write("old\n") }
     end
 
-    @binpath = $0 = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
-
+    @binpath = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
     @deployer = FullTestDeploy.new(config)
     @deployer.deploy
   end
 
+  it "runs the right bundler command" do
+    install_bundler_command_ran = @deployer.commands.detect{ |command| command.index("install_bundler") }
+    install_bundler_command_ran.should_not be_nil
+    install_bundler_command_ran.should == "#{@binpath} install_bundler 1.0.10"
+  end
+
   it "creates a REVISION file" do
     File.exist?(File.join(@deploy_dir, 'current', 'REVISION')).should be_true
   end
 
+  it "restarts the app servers" do
+    File.exist?(File.join(@deploy_dir, 'current', 'restart')).should be_true
+  end
+
+  it "runs 'bundle install' with --deployment" do
+    bundle_install_cmd = @deployer.commands.grep(/bundle _\S+_ install/).first
+    bundle_install_cmd.should_not be_nil
+    bundle_install_cmd.should include('--deployment')
+  end
+
   it "creates a ruby version file" do
     File.exist?(File.join(@deploy_dir, 'shared', 'bundled_gems', 'RUBY_VERSION')).should be_true
   end
@@ -122,48 +188,22 @@ describe "deploying an application" do
     File.exist?(File.join(@deploy_dir, 'shared', 'bundled_gems', 'SYSTEM_VERSION')).should be_true
   end
 
-  if RUBY_VERSION != '1.8.6'
-    it "runs the right bundler command" do
-      install_bundler_command_ran = @deployer.commands.detect{ |command| command.index("install_bundler") }
-      install_bundler_command_ran.should_not be_nil
-      install_bundler_command_ran.should == "#{@binpath} _#{EY::Serverside::VERSION}_ install_bundler 1.0.10"
-    end
-
-    it "runs 'bundle install' with --deployment" do
-      bundle_install_cmd = @deployer.commands.grep(/bundle _\S+_ install/).first
-      bundle_install_cmd.should_not be_nil
-      bundle_install_cmd.should include('--deployment')
-    end
-
-    it "creates binstubs somewhere out of the way" do
-      File.exist?(File.join(@deploy_dir, 'current', 'ey_bundler_binstubs', 'rake')).should be_true
-    end
-
-    it "has the binstubs in the path when migrating" do
-      File.read(File.join(@deploy_dir, 'path-when-migrating')).should include('ey_bundler_binstubs')
-    end
-
-    it "removes bundled_gems directory if the ruby version changed" do
-      clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
-      clear_bundle_cmd.should_not be_nil
-    end
-
-    it "removes bundled_gems directory if the system version changed" do
-      clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
-      clear_bundle_cmd.should_not be_nil
-    end
+  it "removes bundled_gems directory if the ruby version changed" do
+    clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
+    clear_bundle_cmd.should_not be_nil
+  end
 
-    it "creates binstubs somewhere out of the way" do
-      File.exist?(File.join(@deploy_dir, 'current', 'ey_bundler_binstubs', 'rake')).should be_true
-    end
+  it "removes bundled_gems directory if the system version changed" do
+    clear_bundle_cmd = @deployer.commands.grep(/rm -Rf \S+\/bundled_gems/).first
+    clear_bundle_cmd.should_not be_nil
   end
 
-  it "runs 'npm install'" do
-    bundle_install_cmd = @deployer.commands.grep(/npm install/).first
-    bundle_install_cmd.should_not be_nil
+  it "creates binstubs somewhere out of the way" do
+    File.exist?(File.join(@deploy_dir, 'current', 'ey_bundler_binstubs', 'rake')).should be_true
   end
-  it "generates a database.yml file" do
-    File.exist?(File.join(@deploy_dir, 'current', 'config', 'database.yml')).should be_true
+
+  it "has the binstubs in the path when migrating" do
+    File.read(File.join(@deploy_dir, 'path-when-migrating')).should include('ey_bundler_binstubs')
   end
 
   it "runs all the hooks" do
@@ -176,8 +216,4 @@ describe "deploying an application" do
     File.exist?(File.join(@deploy_dir, 'current', 'before_restart.ran')).should be_true
     File.exist?(File.join(@deploy_dir, 'current', 'after_restart.ran' )).should be_true
   end
-
-  it "restarts the app servers" do
-    File.exist?(File.join(@deploy_dir, 'current', 'restart')).should be_true
-  end
 end