engineyard-serverside 1.6.5 → 1.7.0.pre2

data/spec/configuration_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe EY::Serverside::Deploy::Configuration do
+  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' => nil,
+        'branch' => 'branch_from_command_line',
+        'config' => {'custom' => 'custom_from_extra_config'}.to_json
+      })
+
+      @deploy = FullTestDeploy.new(@config, test_shell)
+
+      @yaml_data = {
+        'environments' => {
+          'env_name' => {
+            'copy_exclude' => ['.git'],
+            'migrate' => true,
+            'migration_command' => 'uh oh',
+            'branch' => 'branch_from_ey_yml',
+            'custom' => 'custom_from_ey_yml',
+            'bundle_without' => 'only test',
+          }
+        }
+      }
+    end
+
+    def write_ey_yml(relative_path, data)
+      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', @yaml_data
+      @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', @yaml_data
+      @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', @yaml_data
+      @deploy.load_ey_yml
+      @deploy.config.migrate?.should == false
+    end
+
+    it "loads at lower priority than json config option" do
+      write_ey_yml 'ey.yml', @yaml_data
+      @deploy.load_ey_yml
+      @deploy.config.branch.should == 'branch_from_command_line'
+    end
+
+    it "loads bundle_without from the config, which overrides the default" do
+      write_ey_yml 'ey.yml', @yaml_data
+      @deploy.load_ey_yml
+      @deploy.config.bundle_without.should == 'only test'
+    end
+  end
+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
@@ -60,7 +59,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 +91,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,213 +1,261 @@
 require 'spec_helper'
 
-describe "the deploy-hook API" do
-  def deploy_hook(options={})
-    EY::Serverside::DeployHook.new(options)
-  end
+describe "deploy hooks" do
+  context "successful deploy with all hooks" do
+    before(:all) do
+      deploy_test_application('hooks')
+    end
 
-  def run_hook(options={}, &blk)
-    raise ArgumentError unless block_given?
-    # 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.
-    deploy_hook(options).callback_context.instance_eval(&blk)
+    it "runs all the hooks" do
+      @deploy_dir.join('current', 'before_bundle.ran' ).should exist
+      @deploy_dir.join('current', 'after_bundle.ran'  ).should exist
+      @deploy_dir.join('current', 'before_migrate.ran').should exist
+      @deploy_dir.join('current', 'after_migrate.ran' ).should exist
+      @deploy_dir.join('current', 'before_compile_assets.ran').should exist
+      @deploy_dir.join('current', 'after_compile_assets.ran' ).should exist
+      @deploy_dir.join('current', 'before_symlink.ran').should exist
+      @deploy_dir.join('current', 'after_symlink.ran' ).should exist
+      @deploy_dir.join('current', 'before_restart.ran').should exist
+      @deploy_dir.join('current', 'after_restart.ran' ).should exist
+    end
   end
 
-  context "#run" do
-    it "is available" do
-      run_hook { respond_to?(:run) }.should be_true
+  context "with failing deploy hook" do
+    before(:all) do
+      begin
+        deploy_test_application('hook_fails')
+      rescue EY::Serverside::RemoteFailure
+      end
     end
 
-    it "runs commands like the shell does" do
-      ENV['COUNT'] = 'Chocula'
-      File.unlink("/tmp/deploy_hook_spec.the_count") rescue nil
+    it "retains the failed release" do
+      release_name = File.basename(@config.release_path)
+      @deploy_dir.join('releases_failed', release_name).should be_directory
+    end
+  end
 
-      run_hook { run("echo $COUNT > /tmp/deploy_hook_spec.the_count") }
+  context "deploy hook API" do
 
-      IO.read("/tmp/deploy_hook_spec.the_count").strip.should == "Chocula"
+    def deploy_hook(options={})
+      config = EY::Serverside::Deploy::Configuration.new(options)
+      EY::Serverside::DeployHook.new(config, test_shell)
     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
-    end
-  end
+    context "#run" do
+      it "is available" do
+        deploy_hook.eval_hook('respond_to?(:run)').should be_true
+      end
 
-  context "#sudo" do
-    it "is available" do
-      run_hook { respond_to?(:sudo) }.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
 
-    it "runs things with sudo" do
-      callback = deploy_hook.callback_context
-      callback.should_receive(:system).with("sudo sh -l -c 'do it as root'").and_return(true)
-      callback.instance_eval { sudo("do it as root") }
-    end
-  end
+        deploy_hook.eval_hook('run("echo $COUNT > /tmp/deploy_hook_spec.the_count")')
 
-  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
-    end
-  end
+        IO.read("/tmp/deploy_hook_spec.the_count").strip.should == "Chocula"
+      end
 
-  context "the @node ivar" do
-    before(:each) do
-      EY::Serverside.dna_json = {
-        'instance_role' => 'solo',
-        'applications' => {
-          'myapp' => {
-            'type' => 'rails',
-            'branch' => 'master',
-          }
-        }
-      }.to_json
+      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
+      end
     end
 
-    it "is available" do
-      run_hook { @node.nil? }.should be_false
-    end
+    context "#sudo" do
+      it "is available" do
+        deploy_hook.eval_hook('respond_to?(:sudo)').should be_true
+      end
 
-    it "has indifferent access" do
-      run_hook { @node[:instance_role]  }.should == 'solo'
-      run_hook { @node['instance_role'] }.should == 'solo'
+      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")
+        hook.callback_context.shell.should_receive(:logged_system).with(cmd).and_return(result)
+        hook.eval_hook('sudo("do it as root") || raise("failed")')
+      end
     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'
+    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
-  end
 
-  context "the @configuration ivar" do
-    it "is available" do
-      run_hook { @configuration.nil? }.should be_false
-    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 the configuration in it" do
-      run_hook('bert' => 'ernie') { @configuration.bert }.should == 'ernie'
-    end
+      it "has account_name" do
+        @hook.eval_hook('account_name').should == 'acc'
+      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'
-    end
+      it "has environment_name" do
+        @hook.eval_hook('environment_name').should == 'env'
+      end
 
-    [:repository_cache,
-      :release_path,
-      :branch,
-      :shared_path,
-      :deploy_to,
-      :user,
-      :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
+      it "has app_name" do
+        @hook.eval_hook('app_name').should == 'app'
       end
     end
-  end
 
-  context "environment variables" do
-    it "sets the framework env variables" do
-      run_hook('framework_env' => 'production') { ENV['RAILS_ENV'] }.should == 'production'
-      run_hook('framework_env' => 'production') { ENV['RACK_ENV']  }.should == 'production'
-      run_hook('framework_env' => 'production') { ENV['MERB_ENV']  }.should == 'production'
-      run_hook('framework_env' => 'production') { ENV['NODE_ENV']  }.should == 'production'
-    end
-  end
+    context "the @node ivar" do
+      before(:each) do
+        EY::Serverside.dna_json = {
+          'instance_role' => 'solo',
+          'applications' => {
+            'myapp' => {
+              'type' => 'rails',
+              'branch' => 'master',
+            }
+          }
+        }.to_json
+      end
+
+      it "is available" do
+        deploy_hook.eval_hook('@node.nil?').should be_false
+      end
 
-  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"},
-      ]
+      it "has indifferent access" do
+        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
+        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
 
-    def where_code_runs_with(method, *args)
-      scenarios.map do |s|
-        hook_result = run_hook('current_roles' => s[:instance_role].split(','), 'current_name' => s[:name]) do
-          send(method, *args) { 'ran!' }
-        end
+    context "the @configuration ivar" do
+      it "is available" do
+        deploy_hook.eval_hook('@configuration.nil?').should be_false
+      end
+
+      it "has the configuration in it" do
+        deploy_hook('bert' => 'ernie').eval_hook('@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'
+      end
 
-        if hook_result == 'ran!'
-          result = s[:instance_role]
-          result << "_#{s[:name]}" if s[:name]
-          result
+      [:repository_cache,
+        :release_path,
+        :branch,
+        :shared_path,
+        :deploy_to,
+        :user,
+        :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
         end
-      end.compact
+      end
     end
 
-    it "#on_app_master runs on app masters and solos" do
-      where_code_runs_with(:on_app_master).should == %w(solo app_master)
+    context "environment variables" do
+      it "sets the framework env variables" do
+        run_hook('framework_env' => 'production') { ENV['RAILS_ENV'] }.should == 'production'
+        run_hook('framework_env' => 'production') { ENV['RACK_ENV']  }.should == 'production'
+        run_hook('framework_env' => 'production') { ENV['MERB_ENV']  }.should == 'production'
+        run_hook('framework_env' => 'production') { ENV['NODE_ENV']  }.should == 'production'
+      end
     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)
-    end
+    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' ],
+        ]
+      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 ==
-        %w(solo app_master app multi_role,app multi,util util_alpha util_beta util_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("_")
+        end.compact
+      end
 
-    it "#on_utilities() runs on all utility instances" do
-      where_code_runs_with(:on_utilities).should ==
-        %w(multi,util util_alpha util_beta util_gamma)
-    end
+      it "#on_app_master runs on app masters and solos" do
+        where_code_runs_with("on_app_master").should == %w(solo app_master)
+      end
 
-    it "#on_utilities('sometype') runs on only utilities of type 'sometype'" do
-      where_code_runs_with(:on_utilities, 'alpha').should == %w(util_alpha)
-    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)
+      end
 
-    it "#on_utilities('type1', 'type2') runs on utilities of both types" do
-      where_code_runs_with(:on_utilities, 'alpha', 'beta').should ==
-        %w(util_alpha util_beta)
-    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 ==
+          %w(solo app_master app multi_role,app multi,util util_alpha util_beta util_gamma)
+      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')
-    end
+      it "#on_utilities() runs on all utility instances" do
+        where_code_runs_with("on_utilities").should ==
+          %w(multi,util util_alpha util_beta util_gamma)
+      end
 
-  end
+      it "#on_utilities('sometype') runs on only utilities of type 'sometype'" do
+        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 ==
+          %w(util_alpha util_beta)
+      end
 
-  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
+      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')")
+      end
     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}/
-      deploy_hook.syntax_error(hook_path).should =~ match
+    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
+      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}/
+      end
     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' }
+    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'
+      end
+
+      it "has info, warning, debug, logged_system, and access to shell" do
+        deploy_hook.eval_hook('respond_to?(:info)         ').should be_true
+        deploy_hook.eval_hook('respond_to?(:warning)      ').should be_true
+        deploy_hook.eval_hook('respond_to?(:debug)        ').should be_true
+        deploy_hook.eval_hook('respond_to?(:logged_system)').should be_true
+        deploy_hook.eval_hook('respond_to?(:shell)        ').should be_true
+      end
     end
   end
 end