engineyard-serverside 2.1.4 → 2.2.0.pre

data/lib/engineyard-serverside/strategies/git.rb

@@ -76,7 +76,7 @@ module EY
 
       private
         def run(cmd)
-          shell.logged_system(cmd).success?
+          EY::Serverside::Spawner.run(cmd, shell, nil).success?
         end
 
         def in_repository_cache

data/lib/engineyard-serverside/task.rb

@@ -77,11 +77,11 @@ Please consider:
       end
 
       def run(cmd, &block)
-        servers.roles(@roles).run(shell, cmd, &block)
+        servers.roles(@roles).run(cmd, &block)
       end
 
       def sudo(cmd, &block)
-        servers.roles(@roles).sudo(shell, cmd, &block)
+        servers.roles(@roles).sudo(cmd, &block)
       end
 
     end

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '2.1.4'
+    VERSION = '2.2.0.pre'
   end
 end

data/spec/bundler_deploy_spec.rb

@@ -38,7 +38,9 @@ describe "Deploying an application that uses Bundler" do
     end
 
     it "generates bundler binstubs" do
-      deploy_dir.join('current', 'ey_bundler_binstubs', 'rake').should exist
+      pending "doesn't work with mocked bundler" do
+        deploy_dir.join('current', 'ey_bundler_binstubs', 'rake').should exist
+      end
     end
   end
 
@@ -72,14 +74,14 @@ describe "Deploying an application that uses Bundler" do
   context "with a failing Gemfile" do
     before(:all) do
       begin
-        deploy_test_application('bundle_fails', :verbose => false)
+        deploy_test_application('bundle_fails', 'bundle_install_fails' => true, 'verbose' => false)
       rescue EY::Serverside::RemoteFailure
       end
     end
 
     it "prints the failure to the log" do
       out = read_output
-      out.should =~ %r|this-gem-does-not-exist-which-makes-bundle-install-fail|
+      out.should =~ %r|bundle install failure|
       deploy_dir.join('current', 'after_bundle.ran' ).should_not exist
     end
   end

data/spec/deploy_hook_spec.rb

@@ -89,20 +89,18 @@ describe "deploy hooks" do
 
       it "runs things with sudo" do
         hook = deploy_hook
-        cmd = "sudo sh -l -c 'do it as root'"
-        result = EY::Serverside::Shell::CommandResult.new(cmd, 0, "out\nerr", test_servers.first)
-        hook.callback_context.shell.should_receive(:logged_system).with(cmd).and_return(result)
-        hook.eval_hook('sudo("do it as root") || raise("failed")')
+        mock_sudo do
+          hook.eval_hook('sudo("true") || raise("failed")')
+        end
       end
 
       it "raises when the bang method alternative is used" do
         hook = deploy_hook
-        cmd = "sudo sh -l -c false"
-        result = EY::Serverside::Shell::CommandResult.new(cmd, 1, "fail", test_servers.first)
-        hook.callback_context.shell.should_receive(:logged_system).with(cmd).and_return(result)
-        lambda {
-          hook.eval_hook('sudo!("false")')
-        }.should raise_error(RuntimeError)
+        mock_sudo do
+          lambda {
+            hook.eval_hook('sudo!("false")')
+          }.should 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|

data/spec/git_strategy_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "the git deploy strategy" do
   subject do
     fixtures_dir = Pathname.new(__FILE__).dirname.join("fixtures")
-    gitrepo_dir = tmpdir.join("gitrepo-#{Time.now.to_i}-#{$$}")
+    gitrepo_dir = tmpdir.join("gitrepo-#{Time.now.utc.strftime("%Y%m%d%H%M%S")}#{Time.now.tv_usec}-#{$$}")
     gitrepo_dir.mkdir
     system "tar xzf #{fixtures_dir.join('gitrepo.tar.gz')} --strip-components 1 -C #{gitrepo_dir}"
 

data/spec/nodejs_deploy_spec.rb

@@ -1,14 +1,15 @@
 require 'spec_helper'
 
 describe "Deploying an application that uses Node.js and NPM" do
-  before(:all) do
-    deploy_test_application('nodejs')
+  with_npm_mocked do |mocked|
+    before(:all) do
+      mock_npm if mocked
+      deploy_test_application('nodejs')
+    end
+
+    it "runs 'npm install'" do
+      install_cmd = @deployer.commands.grep(/npm install/).first
+      install_cmd.should_not be_nil
+    end
   end
-
-  it "runs 'npm install'" do
-    install_cmd = @deployer.commands.grep(/npm install/).first
-    install_cmd.should_not be_nil
-  end
-end if $NPM_INSTALLED
-
-
+end

data/spec/php_deploy_spec.rb

@@ -2,75 +2,67 @@ require 'spec_helper'
 
 describe "Deploying an application that uses PHP and Composer" do
 
-  context "with composer available" do
-
-    context "with a composer.lock" do
-      before(:all) do
-        deploy_test_application('php_composer_lock')
-      end
+  with_composer_mocked do |mocked|
+    context "with composer available" do
+      before(:all) { mock_composer if mocked }
+      context "with a composer.lock" do
+        before(:all) do
+          deploy_test_application('php_composer_lock')
+        end
 
-      it "runs 'composer install'" do
-        install_cmd = @deployer.commands.grep(/composer install/).first
-        install_cmd.should_not be_nil
-      end
+        it "runs 'composer install'" do
+          install_cmd = @deployer.commands.grep(/composer install/).first
+          install_cmd.should_not be_nil
+        end
 
-      it "runs 'composer self-update' before 'composer install'" do
-        update_cmd = nil
-        @deployer.commands.each do |cmd|
-          update_cmd ||= /composer self-update/.match(cmd)
-          if /composer install/.match(cmd)
-            update_cmd.should_not be nil
+        it "runs 'composer self-update' before 'composer install'" do
+          update_cmd = nil
+          @deployer.commands.each do |cmd|
+            update_cmd ||= /composer self-update/.match(cmd)
+            if /composer install/.match(cmd)
+              update_cmd.should_not be nil
+            end
           end
         end
       end
-    end
 
-    context "WITHOUT a composer.lock but with composer.json" do
-      before(:all) do
-        deploy_test_application('php_no_composer_lock')
-      end
+      context "WITHOUT a composer.lock but with composer.json" do
+        before(:all) do
+          deploy_test_application('php_no_composer_lock')
+        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
-      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
+        end
 
-      it "runs 'composer install'" do
-        install_cmd = @deployer.commands.grep(/composer install/).first
-        install_cmd.should_not be_nil
-      end
+        it "runs 'composer install'" do
+          install_cmd = @deployer.commands.grep(/composer install/).first
+          install_cmd.should_not be_nil
+        end
 
-      it "runs 'composer self-update' before 'composer install'" do
-        update_cmd = nil
-        @deployer.commands.each do |cmd|
-          update_cmd ||= /composer self-update/.match(cmd)
-          if /composer install/.match(cmd)
-            update_cmd.should_not be nil
+        it "runs 'composer self-update' before 'composer install'" do
+          update_cmd = nil
+          @deployer.commands.each do |cmd|
+            update_cmd ||= /composer self-update/.match(cmd)
+            if /composer install/.match(cmd)
+              update_cmd.should_not be nil
+            end
           end
         end
+
       end
 
     end
 
-  end if $COMPOSER_INSTALLED
-
-  context "without composer available" do
-
-    context "with a composer.lock" do
+    context "without composer available" do
 
       it "fails to deploy" do
         expect {deploy_test_application('php_composer_lock')}.to raise_error EY::Serverside::RemoteFailure
-      end
-    end
-
-    context "WITHOUT a composer.lock but with composer.json" do
-
-      it "fails to deploy" do
         expect {deploy_test_application('php_no_composer_lock')}.to raise_error EY::Serverside::RemoteFailure
       end
 
     end
-
-  end if !$COMPOSER_INSTALLED
+  end
 end
 

data/spec/server_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe EY::Serverside::Server do
   it "starts off empty" do
-    EY::Serverside::Servers.new([]).should be_empty
+    EY::Serverside::Servers.new([], test_shell).should be_empty
   end
 
   it "loads from hashes" do
-    servers = EY::Serverside::Servers.from_hashes([{:hostname => 'otherhost', :roles => %w[fire water]}])
+    servers = EY::Serverside::Servers.from_hashes([{:hostname => 'otherhost', :roles => %w[fire water]}], test_shell)
     servers.size.should == 1
   end
 
@@ -15,12 +15,12 @@ describe EY::Serverside::Server do
       EY::Serverside::Servers.from_hashes([
         {:hostname => 'otherhost', :roles => [:fire]},
         {:hostname => 'otherhost', :roles => [:water]},
-      ])
+      ], test_shell)
     end.should raise_error(EY::Serverside::Servers::DuplicateHostname)
   end
 
   it "makes sure your roles are symbols at creation time" do
-    servers = EY::Serverside::Servers.from_hashes([{:hostname => 'otherhost', :roles => %w[fire water]}])
+    servers = EY::Serverside::Servers.from_hashes([{:hostname => 'otherhost', :roles => %w[fire water]}], test_shell)
     servers.each { |server| server.roles.should == Set[:fire, :water] }
   end
 
@@ -30,7 +30,7 @@ describe EY::Serverside::Server do
         {:hostname => 'localhost', :roles => [:ice, :cold]},
         {:hostname => 'firewater', :roles => [:fire, :water]},
         {:hostname => 'icewater',  :roles => [:ice, :water]},
-      ])
+      ], test_shell)
     end
 
     it "#roles works with strings or symbols" do

data/spec/spec_helper.rb

@@ -20,6 +20,7 @@ require File.expand_path('../support/integration', __FILE__)
 FIXTURES_DIR = Pathname.new(__FILE__).dirname.join("fixtures")
 TMPDIR = Pathname.new(__FILE__).dirname.parent.join('tmp')
 GROUP = `id -gn`.strip
+INTERNAL_KEY = Pathname.new("~/.ssh/id_rsa").expand_path
 
 module EY
   module Serverside
@@ -31,15 +32,35 @@ module EY
     class Strategies::Git
       def short_log_message(_) "" end
     end
+
+
+    class Paths
+      # This needs to be patched for the tests to succeed, but
+      # the chances of 2 real deploys colliding in the same second
+      # is very very low.
+      def active_release
+        @active_release ||= if Time.now.utc.strftime("%L") =~ /L/ # old ruby
+                              path(:releases, Time.now.utc.strftime("%Y%m%d%H%M%S#{Time.now.tv_usec}"))
+                            else
+                              path(:releases, Time.now.utc.strftime("%Y%m%d%H%M%S%L"))
+                            end
+      end
+    end
+
   end
 end
 
-Spec::Runner.configure do |config|
+module SpecDependencyHelpers
   $NPM_INSTALLED = system('which npm 2>&1')
   unless $NPM_INSTALLED
     $stderr.puts "npm not found; skipping Node.js specs."
   end
 
+  def with_npm_mocked(&block)
+    context("mocked") { yield true }
+    context("unmocked") { yield false } if $NPM_INSTALLED
+  end
+
   $COMPOSER_INSTALLED = system('command -v composer > /dev/null')
   if $COMPOSER_INSTALLED
     $stderr.puts "composer found; skipping tests that expect it to be missing."
@@ -47,6 +68,15 @@ Spec::Runner.configure do |config|
     $stderr.puts "composer not found; skipping tests that expect it to be available."
   end
 
+  def with_composer_mocked(&block)
+    context("mocked") { yield true }
+    context("unmocked") { yield false } if $COMPOSER_INSTALLED
+  end
+end
+
+RSpec.configure do |config|
+  config.extend SpecDependencyHelpers
+
   config.before(:all) do
     make_tmpdir
     EY::Serverside.dna_json = MultiJson.dump({})
@@ -111,7 +141,7 @@ Spec::Runner.configure do |config|
 
   def test_shell(verbose=true)
     @test_shell ||= begin
-                      @log_path = tmpdir.join("serverside-deploy-#{Time.now.to_i}-#{$$}.log")
+                      @log_path = tmpdir.join("serverside-deploy-#{Time.now.to_f}-#{$$}.log")
                       EY::Serverside::Shell.new(:verbose => verbose, :log_path => @log_path, :stdout => stdout, :stderr => stderr)
                     end
   end
@@ -120,13 +150,87 @@ Spec::Runner.configure do |config|
     be_exist
   end
 
+  def bindir
+    @bindir ||= begin
+                  dir = tmpdir.join("ey_test_cmds_#{Time.now.to_f}_#{$$}")
+                  dir.mkpath
+                  dir
+                end
+  end
+
+  def mock_command(cmd, contents, &block)
+    bindir.join(cmd).open('w') do |f|
+      f.write contents
+      f.chmod(0755)
+    end
+    with_mocked_commands(&block) if block_given?
+  end
+
+  def mock_bundler(failure = false, &block)
+    mock_command('bundle', <<-SCRIPT, &block)
+#!#{`which ruby`}
+puts "Bundling gems"
+$stdout.flush
+#{failure && '$stderr.puts "bundle install failure"; exit 1'}
+    SCRIPT
+  end
+
+  def mock_npm(&block)
+    mock_command('npm', <<-SCRIPT, &block)
+#!/bin/bash
+echo "Running npm with $@"
+    SCRIPT
+  end
+
+  def mock_composer(&block)
+    mock_command('composer', <<-SCRIPT, &block)
+#!/bin/bash
+echo "Running composer with $@"
+    SCRIPT
+  end
+
+  def mock_sudo(&block)
+    mock_command('sudo', <<-SCRIPT, &block)
+#!/bin/bash
+echo "$@"
+exec "$@"
+    SCRIPT
+  end
+
+  def with_mocked_commands(&block)
+    with_env('PATH' => "#{bindir}:#{ENV['PATH']}", &block)
+  end
+
+  def with_env(new_env_vars)
+    raise ArgumentError, "with_env takes a block" unless block_given?
+
+    old_env_vars = {}
+    new_env_vars.each do |k, v|
+      if ENV.has_key?(k)
+        old_env_vars[k] = ENV[k]
+      end
+      ENV[k] = v if v
+    end
+
+    yield
+  ensure
+    new_env_vars.keys.each do |k|
+      if old_env_vars.has_key?(k)
+        ENV[k] = old_env_vars[k]
+      else
+        ENV.delete(k)
+      end
+    end
+  end
+
+
   def deploy_dir
-    @deploy_dir ||= tmpdir.join("serverside-deploy-#{Time.now.to_i}-#{$$}")
+    @deploy_dir ||= tmpdir.join("serverside-deploy-#{Time.now.to_f}-#{$$}")
   end
 
   # set up EY::Serverside::Server like we're on a solo
   def test_servers
-    @test_servers ||= EY::Serverside::Servers.from_hashes([{:hostname => 'localhost', :roles => %w[solo], :user => ENV['USER']}])
+    @test_servers ||= EY::Serverside::Servers.from_hashes([{:hostname => 'localhost', :roles => %w[solo], :user => ENV['USER']}], test_shell)
   end
 
   # When a repo fixture name is specified, the files found in the specified
@@ -178,8 +282,12 @@ Spec::Runner.configure do |config|
 
     @binpath = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
     FullTestDeploy.on_create_callback = block
-    capture do
-      EY::Serverside::CLI.start(@argv)
+
+    mock_bundler(options['bundle_install_fails'])
+    with_mocked_commands do
+      capture do
+        EY::Serverside::CLI.start(@argv)
+      end
     end
   ensure
     @deployer = EY::Serverside::Deploy.deployer
@@ -188,6 +296,7 @@ Spec::Runner.configure do |config|
 
   def redeploy_test_application(extra_config = {}, &block)
     raise "Please deploy_test_application first" unless @argv
+    bundle_install_fails = extra_config.delete('bundle_install_fails')
 
     @action = @adapter.deploy do |args|
       extra_config.each do |key,val|
@@ -202,8 +311,13 @@ Spec::Runner.configure do |config|
     @argv = @action.commands.last.to_argv[2..-1]
 
     FullTestDeploy.on_create_callback = block
-    capture do
-      EY::Serverside::CLI.start(@argv)
+
+    mock_bundler(bundle_install_fails)
+
+    with_mocked_commands do
+      capture do
+        EY::Serverside::CLI.start(@argv)
+      end
     end
   ensure
     @deployer = EY::Serverside::Deploy.deployer