engineyard-serverside 1.5.35.pre.2 → 1.6.0.pre

data/spec/basic_deploy_spec.rb

@@ -12,17 +12,17 @@ describe "Deploying an application without Bundler" do
 
     # run a deploy
     config = EY::Serverside::Deploy::Configuration.new({
-        "strategy"      => "IntegrationSpec",
-        "deploy_to"     => @deploy_dir.to_s,
-        "group"         => `id -gn`.strip,
-        "stack"         => 'nginx_passenger',
-        "migrate"       => nil,
-        'app'           => 'foo',
-        'framework_env' => 'staging'
-      })
+      "strategy"      => "IntegrationSpec",
+      "deploy_to"     => @deploy_dir.to_s,
+      "group"         => `id -gn`.strip,
+      "stack"         => 'nginx_passenger',
+      "migrate"       => nil,
+      'app'           => 'foo',
+      'framework_env' => 'staging'
+    })
 
     @binpath = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
-    @deployer = FullTestDeploy.new(config)
+    @deployer = FullTestDeploy.new(config, test_shell)
     @deployer.deploy
   end
 

data/spec/bundler_deploy_spec.rb

@@ -32,7 +32,7 @@ describe "Deploying an application that uses Bundler" do
     end
 
     @binpath = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
-    @deployer = FullTestDeploy.new(config)
+    @deployer = FullTestDeploy.new(config, test_shell)
     @deployer.deploy
   end
 

data/spec/custom_deploy_spec.rb

@@ -11,7 +11,6 @@ describe "the EY::Serverside::Deploy API" do
       # cheat a bit; we don't actually want to do these things
       def require_custom_tasks() end
       def callback(*_) end
-      def puts(*_) 'stfu' end
 
       attr_reader :call_order
       def initialize(*a)
@@ -34,7 +33,7 @@ describe "the EY::Serverside::Deploy API" do
       def disable_maintenance_page()               @call_order << 'disable_maintenance_page'               end
     end
 
-    td = TestDeploy.new(EY::Serverside::Deploy::Configuration.new)
+    td = TestDeploy.new(EY::Serverside::Deploy::Configuration.new, test_shell)
     td.deploy
     td.call_order.should == %w(
       push_code
@@ -52,6 +51,48 @@ describe "the EY::Serverside::Deploy API" do
       cleanup_old_releases)
   end
 
+  describe "ey.yml loading" do
+    before(:each) do
+      @tempdir = `mktemp -d -t ey_yml_spec.XXXXX`.strip
+      @config = EY::Serverside::Deploy::Configuration.new('repository_cache' => @tempdir, 'environment_name' => 'env_name', 'account_name' => 'acc', 'migrate' => 'rake db:migrate', 'config' => {'branch' => 'branch_from_config'}.to_json)
+      @deploy = TestDeploy.new(@config, test_shell)
+    end
+
+    def write_ey_yml(relative_path, data = {'environments' => {'env_name' => {'copy_exclude' => ['.git'], 'migrate' => true, 'branch' => 'branch_from_ey_yaml'}}})
+      FileUtils.mkdir_p(File.join(
+        @tempdir,
+        File.dirname(relative_path)))
+
+      File.open(File.join(@tempdir, relative_path), 'w') do |f|
+        f.write data.to_yaml
+      end
+    end
+
+    it "requires 'ey.yml' and adds any defined methods to the deploy" do
+      write_ey_yml 'ey.yml'
+      @deploy.load_ey_yml
+      @deploy.config.copy_exclude.should == ['.git']
+    end
+
+    it "falls back to 'config/ey.yml'" do
+      write_ey_yml 'config/ey.yml'
+      @deploy.load_ey_yml
+      @deploy.config.copy_exclude.should == ['.git']
+    end
+
+    it "loads at lower priority than command line options" do
+      write_ey_yml 'ey.yml'
+      @deploy.load_ey_yml
+      @deploy.config.migration_command.should == 'rake db:migrate'
+    end
+
+    it "loads at lower priority than json config option" do
+      write_ey_yml 'ey.yml'
+      @deploy.load_ey_yml
+      @deploy.config.branch.should == 'branch_from_config'
+    end
+  end
+
   describe "task overrides" do
     class TestQuietDeploy < EY::Serverside::Deploy
       def puts(*_) 'quiet' end
@@ -60,7 +101,7 @@ describe "the EY::Serverside::Deploy API" do
     before(:each) do
       @tempdir = `mktemp -d -t custom_deploy_spec.XXXXX`.strip
       @config = EY::Serverside::Deploy::Configuration.new('repository_cache' => @tempdir)
-      @deploy = TestQuietDeploy.new(@config)
+      @deploy = TestQuietDeploy.new(@config, test_shell)
     end
 
     def write_eydeploy(relative_path, contents = "def got_new_methods() 'from the file on disk' end")
@@ -92,7 +133,7 @@ describe "the EY::Serverside::Deploy API" do
         def value() 'base' end
       end
 
-      deploy = TestDeploySuper.new(@config)
+      deploy = TestDeploySuper.new(@config, test_shell)
       deploy.require_custom_tasks.should be_true
       deploy.value.should == "base + derived"
     end

data/spec/deploy_hook_spec.rb

@@ -1,67 +1,71 @@
 require 'spec_helper'
 
 describe "the deploy-hook API" do
-  before(:each) do
-    @hook = EY::Serverside::DeployHook.new(options)
-    @callback_context = EY::Serverside::DeployHook::CallbackContext.new(@hook.config)
-  end
-
-  def run_hook(options={}, &blk)
-    raise ArgumentError unless block_given?
-    options.each do |k, v|
-      @callback_context.configuration[k] = v
-    end
-
-    # The hooks on the filesystem are run by passing a string to
-    # context.instance_eval, not a block. However, using a block
-    # should allow us to get the same degree of test coverage and
-    # still let us have things like syntax checking work on this spec
-    # file.
-    @callback_context.instance_eval(&blk)
+  def deploy_hook(options={})
+    config = EY::Serverside::Deploy::Configuration.new(options)
+    EY::Serverside::DeployHook.new(config, test_shell)
   end
 
   context "#run" do
     it "is available" do
-      run_hook { respond_to?(:run) }.should be_true
+      deploy_hook.eval_hook('respond_to?(:run)').should be_true
     end
 
     it "runs commands like the shell does" do
       ENV['COUNT'] = 'Chocula'
       File.unlink("/tmp/deploy_hook_spec.the_count") rescue nil
 
-      run_hook { run("echo $COUNT > /tmp/deploy_hook_spec.the_count") }
+      deploy_hook.eval_hook('run("echo $COUNT > /tmp/deploy_hook_spec.the_count")')
 
       IO.read("/tmp/deploy_hook_spec.the_count").strip.should == "Chocula"
     end
 
     it "returns true/false to indicate the command's success" do
-      run_hook { run("true") }.should be_true
-      run_hook { run("false") }.should be_false
+      deploy_hook.eval_hook('run("true")').should be_true
+      deploy_hook.eval_hook('run("false")').should be_false
     end
   end
 
   context "#sudo" do
     it "is available" do
-      run_hook { respond_to?(:sudo) }.should be_true
+      deploy_hook.eval_hook('respond_to?(:sudo)').should be_true
     end
 
     it "runs things with sudo" do
-      @callback_context.should_receive(:system).with("sudo sh -l -c 'do it as root'").and_return(true)
-
-      run_hook { sudo("do it as root") }
+      hook = deploy_hook
+      hook.callback_context.shell.should_receive(:logged_system).with("sudo sh -l -c 'do it as root'").and_return(true)
+      hook.eval_hook('sudo("do it as root")')
     end
   end
 
   context "capistrano-ish methods" do
     it "has them" do
-      run_hook { respond_to?(:latest_release)    }.should be_true
-      run_hook { respond_to?(:previous_release)  }.should be_true
-      run_hook { respond_to?(:all_releases)      }.should be_true
-      run_hook { respond_to?(:current_path)      }.should be_true
-      run_hook { respond_to?(:shared_path)       }.should be_true
-      run_hook { respond_to?(:release_dir)       }.should be_true
-      run_hook { respond_to?(:failed_release_dir)}.should be_true
-      run_hook { respond_to?(:release_path)      }.should be_true
+      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
+    end
+  end
+
+  context "access to command line options that should be handed through to the config" do
+    before do
+      @hook = deploy_hook({'app' => 'app', 'environment_name' => 'env', 'account_name' => 'acc'})
+    end
+
+    it "has account_name" do
+      @hook.eval_hook('account_name').should == 'acc'
+    end
+
+    it "has environment_name" do
+      @hook.eval_hook('environment_name').should == 'env'
+    end
+
+    it "has app_name" do
+      @hook.eval_hook('app_name').should == 'app'
     end
   end
 
@@ -79,34 +83,34 @@ describe "the deploy-hook API" do
     end
 
     it "is available" do
-      run_hook { @node.nil? }.should be_false
+      deploy_hook.eval_hook('@node.nil?').should be_false
     end
 
     it "has indifferent access" do
-      run_hook { @node[:instance_role]  }.should == 'solo'
-      run_hook { @node['instance_role'] }.should == 'solo'
+      deploy_hook.eval_hook('@node[:instance_role] ').should == 'solo'
+      deploy_hook.eval_hook('@node["instance_role"]').should == 'solo'
     end
 
     it "has deep indifferent access" do
-      run_hook { @node['applications']['myapp']['type'] }.should == 'rails'
-      run_hook { @node[:applications]['myapp'][:type]   }.should == 'rails'
-      run_hook { @node[:applications][:myapp][:type]    }.should == 'rails'
+      deploy_hook.eval_hook('@node["applications"]["myapp"]["type"]').should == 'rails'
+      deploy_hook.eval_hook('@node[:applications]["myapp"][:type]  ').should == 'rails'
+      deploy_hook.eval_hook('@node[:applications][:myapp][:type]   ').should == 'rails'
     end
   end
 
   context "the @configuration ivar" do
     it "is available" do
-      run_hook { @configuration.nil? }.should be_false
+      deploy_hook.eval_hook('@configuration.nil?').should be_false
     end
 
     it "has the configuration in it" do
-      run_hook('bert' => 'ernie') { @configuration.bert }.should == 'ernie'
+      deploy_hook('bert' => 'ernie').eval_hook('@configuration.bert').should == 'ernie'
     end
 
     it "can be accessed with method calls, with [:symbols], or ['strings']" do
-      run_hook('bert' => 'ernie') { @configuration.bert }.should == 'ernie'
-      run_hook('bert' => 'ernie') { @configuration[:bert] }.should == 'ernie'
-      run_hook('bert' => 'ernie') { @configuration['bert'] }.should == 'ernie'
+      deploy_hook('bert' => 'ernie').eval_hook('@configuration.bert   ').should == 'ernie'
+      deploy_hook('bert' => 'ernie').eval_hook('@configuration[:bert] ').should == 'ernie'
+      deploy_hook('bert' => 'ernie').eval_hook('@configuration["bert"]').should == 'ernie'
     end
 
     [:repository_cache,
@@ -118,7 +122,7 @@ describe "the deploy-hook API" do
       :revision,
       :environment].each do |attribute|
       it "has the #{attribute.inspect} attribute for compatibility with chef-deploy" do
-        run_hook { @configuration.has_key?(attribute) }.should be_true
+        deploy_hook.eval_hook("@configuration.has_key?(#{attribute.inspect})").should be_true
       end
     end
   end
@@ -126,62 +130,58 @@ describe "the deploy-hook API" do
   context "has methods to run code only on certain instances" do
     def scenarios
       [
-        {:instance_role => 'solo'},
-        {:instance_role => 'app_master'},
-        {:instance_role => 'app'},
-        {:instance_role => 'db_master'},
-        {:instance_role => 'db_slave'},
-        {:instance_role => 'multi_role,app'},
-        {:instance_role => 'multi,util'},
-        {:instance_role => 'util', :name => "alpha"},
-        {:instance_role => 'util', :name => "beta"},
-        {:instance_role => 'util', :name => "gamma"},
+        ['solo'          ],
+        ['app_master'    ],
+        ['app'           ],
+        ['db_master'     ],
+        ['db_slave'      ],
+        ['multi_role,app'],
+        ['multi,util'    ],
+        ['util',         'alpha' ],
+        ['util',         'beta'  ],
+        ['util',         'gamma' ],
       ]
     end
 
-    def where_code_runs_with(method, *args)
-      scenarios.map do |s|
-        @callback_context.configuration[:current_roles] = s[:instance_role].split(',')
-        @callback_context.configuration[:current_name] = s[:name]
-
-        if run_hook { send(method, *args) { 'ran!'} } == 'ran!'
-          result = s[:instance_role]
-          result << "_#{s[:name]}" if s[:name]
-          result
-        end
+    def where_code_runs_with(code)
+      scenarios.select do |role, name|
+        hook = deploy_hook(:current_roles => role.split(','), :current_name => name)
+        hook.eval_hook("#{code} { 'ran' } == 'ran'")
+      end.map do |scenario|
+        scenario.compact.join("_")
       end.compact
     end
 
     it "#on_app_master runs on app masters and solos" do
-      where_code_runs_with(:on_app_master).should == %w(solo app_master)
+      where_code_runs_with("on_app_master").should == %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)
+      where_code_runs_with("on_app_servers").should == %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 ==
+      where_code_runs_with("on_app_servers_and_utilities").should ==
         %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 ==
+      where_code_runs_with("on_utilities").should ==
         %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)
+      where_code_runs_with("on_utilities('alpha')").should == %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 ==
+      where_code_runs_with("on_utilities('alpha', 'beta')").should ==
         %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 ==
-        where_code_runs_with(:on_utilities, 'alpha', 'beta')
+      where_code_runs_with("on_utilities(%w[alpha beta])").should ==
+        where_code_runs_with("on_utilities('alpha', 'beta')")
     end
 
   end
@@ -189,20 +189,19 @@ describe "the deploy-hook API" do
   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__)
-      @hook.syntax_error(hook_path).should be_nil
+      deploy_hook.syntax_error(hook_path).should 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__)
-      desc = "spec/fixtures/invalid_hook.rb:1: syntax error, unexpected '^'"
-      match = /#{Regexp.escape desc}/
-      @hook.syntax_error(hook_path).should =~ match
+      error = Regexp.escape("spec/fixtures/invalid_hook.rb:1: syntax error, unexpected '^'")
+      deploy_hook.syntax_error(hook_path).should =~ /#{error}/
     end
   end
 
   context "is compatible with older deploy hook scripts" do
     it "#current_role returns the first role" do
-      run_hook(:current_roles => %w(a b)) { current_role.should == 'a' }
+      deploy_hook(:current_roles => %w(a b)).eval_hook('current_role').should == 'a'
     end
   end
 end

data/spec/deprecation_spec.rb

@@ -12,34 +12,12 @@ describe EY::Serverside do
     $stderr = @original_stderr
   end
 
-  def check_deprecation(new_const, prints_warning = true)
-    old_name = new_const.to_s.gsub('EY::Serverside::', 'EY::')
-    eval(old_name).should == new_const
-    @warnings.string.should include(old_name) if prints_warning
-  end
-
-  it "preserves the old constants" do
-    names = %w[CLI Deploy DeployBase Deploy::Configuration
-               DeployHook LockfileParser LoggedOutput Server Task
-               Strategies Strategies::Git]
-
-    names.map do |name|
-      const = eval("::EY::Serverside::#{name}")
-      # The way deprecations are implemented currently, we don't print
-      # warning messages for constants that aren't directly under EY::
-      prints_warning = name.include?('::') ? false : true
-      check_deprecation(const, prints_warning)
-    end
-  end
-
-  it "deprecates EY.dna_json and EY.node" do
-    EY.dna_json.should == EY::Serverside.dna_json
-    @warnings.string.should include("EY.dna_json")
-    EY.node.should == EY::Serverside.node
-    @warnings.string.should include("EY.node")
+  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")
   end
 
   it "doesn't interfere with unrelated constants" do
-    lambda{ EY::WTFNotDefined }.should raise_error(NameError, /uninitialized constant.*EY::WTFNotDefined/)
+    lambda{ EY::Serverside::WTFNotDefined }.should raise_error(NameError, /uninitialized constant.*WTFNotDefined/)
   end
 end

data/spec/git_strategy_spec.rb

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

data/spec/nodejs_deploy_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe "Deploying an application that uses Node.js and NPM" do
   def deploy_test_application
-    @deploy_dir = File.join(Dir.tmpdir, "serverside-deploy-#{Time.now.to_i}-#{$$}")
+    @deploy_dir = Pathname.new(Dir.tmpdir).join("serverside-deploy-#{Time.now.to_i}-#{$$}")
 
     # set up EY::Serverside::Server like we're on a solo
     EY::Serverside::Server.reset
@@ -19,7 +19,7 @@ describe "Deploying an application that uses Node.js and NPM" do
       })
 
     @binpath = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
-    @deployer = FullTestDeploy.new(config)
+    @deployer = FullTestDeploy.new(config, test_shell)
     @deployer.deploy do
       FileUtils.mkdir_p(config.repository_cache) # block runs before deploy
       @deployer.generate_package_json_in(config.repository_cache)