engineyard-serverside 1.6.0.pre5 → 1.6.3

data/spec/deploy_hook_spec.rb

@@ -1,71 +1,67 @@
 require 'spec_helper'
 
 describe "the deploy-hook API" do
-  def deploy_hook(options={})
-    config = EY::Serverside::Deploy::Configuration.new(options)
-    EY::Serverside::DeployHook.new(config, test_shell)
+  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)
   end
 
   context "#run" do
     it "is available" do
-      deploy_hook.eval_hook('respond_to?(:run)').should be_true
+      run_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
 
-      deploy_hook.eval_hook('run("echo $COUNT > /tmp/deploy_hook_spec.the_count")')
+      run_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
-      deploy_hook.eval_hook('run("true")').should be_true
-      deploy_hook.eval_hook('run("false")').should be_false
+      run_hook { run("true") }.should be_true
+      run_hook { run("false") }.should be_false
     end
   end
 
   context "#sudo" do
     it "is available" do
-      deploy_hook.eval_hook('respond_to?(:sudo)').should be_true
+      run_hook { respond_to?(:sudo) }.should be_true
     end
 
     it "runs things with sudo" do
-      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")')
+      @callback_context.should_receive(:system).with("sudo sh -l -c 'do it as root'").and_return(true)
+
+      run_hook { sudo("do it as root") }
     end
   end
 
   context "capistrano-ish methods" do
     it "has them" do
-      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'
+      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
     end
   end
 
@@ -83,34 +79,34 @@ describe "the deploy-hook API" do
     end
 
     it "is available" do
-      deploy_hook.eval_hook('@node.nil?').should be_false
+      run_hook { @node.nil? }.should be_false
     end
 
     it "has indifferent access" do
-      deploy_hook.eval_hook('@node[:instance_role] ').should == 'solo'
-      deploy_hook.eval_hook('@node["instance_role"]').should == 'solo'
+      run_hook { @node[:instance_role]  }.should == 'solo'
+      run_hook { @node['instance_role'] }.should == 'solo'
     end
 
     it "has deep indifferent access" do
-      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'
+      run_hook { @node['applications']['myapp']['type'] }.should == 'rails'
+      run_hook { @node[:applications]['myapp'][:type]   }.should == 'rails'
+      run_hook { @node[:applications][:myapp][:type]    }.should == 'rails'
     end
   end
 
   context "the @configuration ivar" do
     it "is available" do
-      deploy_hook.eval_hook('@configuration.nil?').should be_false
+      run_hook { @configuration.nil? }.should be_false
     end
 
     it "has the configuration in it" do
-      deploy_hook('bert' => 'ernie').eval_hook('@configuration.bert').should == 'ernie'
+      run_hook('bert' => 'ernie') { @configuration.bert }.should == 'ernie'
     end
 
     it "can be accessed with method calls, with [:symbols], or ['strings']" do
-      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'
+      run_hook('bert' => 'ernie') { @configuration.bert }.should == 'ernie'
+      run_hook('bert' => 'ernie') { @configuration[:bert] }.should == 'ernie'
+      run_hook('bert' => 'ernie') { @configuration['bert'] }.should == 'ernie'
     end
 
     [:repository_cache,
@@ -122,7 +118,7 @@ describe "the deploy-hook API" do
       :revision,
       :environment].each do |attribute|
       it "has the #{attribute.inspect} attribute for compatibility with chef-deploy" do
-        deploy_hook.eval_hook("@configuration.has_key?(#{attribute.inspect})").should be_true
+        run_hook { @configuration.has_key?(attribute) }.should be_true
       end
     end
   end
@@ -130,58 +126,62 @@ describe "the deploy-hook API" do
   context "has methods to run code only on certain instances" do
     def scenarios
       [
-        ['solo'          ],
-        ['app_master'    ],
-        ['app'           ],
-        ['db_master'     ],
-        ['db_slave'      ],
-        ['multi_role,app'],
-        ['multi,util'    ],
-        ['util',         'alpha' ],
-        ['util',         'beta'  ],
-        ['util',         'gamma' ],
+        {: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"},
       ]
     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("_")
+    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
       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,19 +189,20 @@ 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__)
-      deploy_hook.syntax_error(hook_path).should be_nil
+      @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__)
-      error = Regexp.escape("spec/fixtures/invalid_hook.rb:1: syntax error, unexpected '^'")
-      deploy_hook.syntax_error(hook_path).should =~ /#{error}/
+      desc = "spec/fixtures/invalid_hook.rb:1: syntax error, unexpected '^'"
+      match = /#{Regexp.escape desc}/
+      @hook.syntax_error(hook_path).should =~ match
     end
   end
 
   context "is compatible with older deploy hook scripts" do
     it "#current_role returns the first role" do
-      deploy_hook(:current_roles => %w(a b)).eval_hook('current_role').should == 'a'
+      run_hook(:current_roles => %w(a b)) { current_role.should == 'a' }
     end
   end
 end

data/spec/deprecation_spec.rb

@@ -12,12 +12,34 @@ describe EY::Serverside do
     $stderr = @original_stderr
   end
 
-  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")
+  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")
   end
 
   it "doesn't interfere with unrelated constants" do
-    lambda{ EY::Serverside::WTFNotDefined }.should raise_error(NameError, /uninitialized constant.*WTFNotDefined/)
+    lambda{ EY::WTFNotDefined }.should raise_error(NameError, /uninitialized constant.*EY::WTFNotDefined/)
   end
 end

data/spec/git_strategy_spec.rb

@@ -2,12 +2,8 @@ require 'spec_helper'
 
 describe "the git deploy strategy" do
   subject do
-    EY::Serverside::Strategies::Git.new(
-      test_shell,
-      :repo => File.join(GITREPO_DIR, 'git'),
-      :repository_cache => GITREPO_DIR,
-      :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/logged_output_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'tempfile'
+require 'timecop'
+
+class SampleLogUser
+  include EY::Serverside::LoggedOutput
+  def initialize
+    EY::Serverside::LoggedOutput.logfile = tempfile.path
+    EY::Serverside::LoggedOutput.verbose = true
+  end
+
+  def starting_time
+    @starting_time ||= Time.now
+  end
+
+  def tempfile
+    @tempfile ||= Tempfile.new('logged_output')
+  end
+end
+
+describe EY::Serverside::LoggedOutput do
+  before do
+    EY::Serverside::LoggedOutput.enable_actual_info!
+    @log_user = SampleLogUser.new
+  end
+
+  after do
+    EY::Serverside::LoggedOutput.disable_actual_info!
+  end
+
+  it "has a timestamp before each line" do
+    time1 = Time.local(2008, 9, 1, 12, 0, 0)
+    time2 = Time.local(2008, 9, 1, 12, 3, 5)
+    time3 = Time.local(2008, 9, 1, 12, 10, 25)
+
+    Timecop.freeze(time1) do
+      @log_user.debug('test1')
+      @log_user.warning('test2')
+    end
+    Timecop.freeze(time2) do
+      @log_user.info('test3')
+
+      @log_user.debug("test11\ntest12\ntest13")
+      @log_user.warning("test21\ntest22\ntest23")
+    end
+    Timecop.freeze(time3) do
+      @log_user.info("test31\ntest32\ntest33")
+    end
+
+    timestamp_1 = "+ 0m 00s "
+    timestamp_2 = "+ 3m 05s "
+    timestamp_3 = "+10m 25s "
+    File.read(@log_user.tempfile.path).should == "#{timestamp_1}test1\n#{timestamp_1}!> WARNING: test2\n\n#{timestamp_2}test3\n#{timestamp_2}test11\n#{timestamp_2}test12\n#{timestamp_2}test13\n#{timestamp_2}!> WARNING: test21\n#{timestamp_2}!> test22\n#{timestamp_2}!> test23\n\n#{timestamp_3}test31\n#{timestamp_3}test32\n#{timestamp_3}test33\n"
+  end
+end

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 = Pathname.new(Dir.tmpdir).join("serverside-deploy-#{Time.now.to_i}-#{$$}")
+    @deploy_dir = File.join(Dir.tmpdir, "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, test_shell)
+    @deployer = FullTestDeploy.new(config)
     @deployer.deploy do
       FileUtils.mkdir_p(config.repository_cache) # block runs before deploy
       @deployer.generate_package_json_in(config.repository_cache)

data/spec/services_deploy_spec.rb

@@ -20,13 +20,12 @@ describe "Deploying an application with services" do
         "stack"         => 'nginx_passenger',
         "migrate"       => nil,
         'app'           => 'foo',
-        'environment'   => 'env',
-        'account'       => 'acc',
         'framework_env' => 'staging'
       })
 
+    EY::Serverside::LoggedOutput.verbose = true
     @binpath = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
-    FullTestDeploy.new(config, test_shell)
+    FullTestDeploy.new(config)
   end
 
   def exist
@@ -66,7 +65,7 @@ DEPENDENCIES
       end
 
       it "warns about missing ey_config" do
-        read_stderr.should include("WARNING: Gemfile.lock does not contain ey_config")
+        @deployer.infos.should be_any { |info| info =~ /WARNING: Gemfile.lock does not contain ey_config/ }
       end
 
     end
@@ -76,7 +75,7 @@ DEPENDENCIES
       end
 
       it "works without warnings" do
-        read_output.should_not =~ /WARNING/
+        @deployer.infos.should_not be_any { |info| info =~ /WARNING/ }
       end
 
     end
@@ -102,7 +101,7 @@ DEPENDENCIES
       @symlinked_services_file.should be_symlink
       @shared_services_file.read.should == "#{@invalid_services_yml}\n"
 
-      read_output.should_not =~ /WARNING/
+      @deployer.infos.should_not be_any { |info| info =~ /WARNING/ }
     end
   end
 
@@ -126,7 +125,7 @@ DEPENDENCIES
       @symlinked_services_file.should be_symlink
       @shared_services_file.read.should == "#{@services_yml}\n"
 
-      read_output.should_not =~ /WARNING/
+      @deployer.infos.should_not be_any { |info| info =~ /WARNING/ }
     end
 
     describe "followed by a deploy that can't find the command" do
@@ -145,7 +144,7 @@ DEPENDENCIES
         @symlinked_services_file.should be_symlink
         @shared_services_file.read.should == "#{@services_yml}\n"
 
-        read_output.should_not =~ /WARNING/
+        @deployer.infos.should_not be_any { |info| info =~ /WARNING/ }
       end
 
     end
@@ -167,7 +166,7 @@ DEPENDENCIES
         @symlinked_services_file.should be_symlink
         @shared_services_file.read.should == "#{@services_yml}\n"
 
-        read_stderr.should include('WARNING: External services configuration not updated')
+        @deployer.infos.should be_any { |info| info =~ /WARNING: External services configuration not updated/ }
       end
 
       it "does not log a warning or symlink a config file when there is no existing services file" do
@@ -177,7 +176,7 @@ DEPENDENCIES
         @shared_services_file.should_not exist
         @symlinked_services_file.should_not exist
 
-        read_output.should_not =~ /WARNING/
+        @deployer.infos.should_not be_any { |info| info =~ /WARNING/ }
       end
 
     end
@@ -200,7 +199,7 @@ DEPENDENCIES
         @symlinked_services_file.should be_symlink
         @shared_services_file.read.should == "#{@services_yml}\n"
 
-        read_output.should_not =~ /WARNING/
+        @deployer.infos.should_not be_any { |info| info =~ /WARNING/ }
       end
 
     end