engineyard-serverside 2.8.0.pre → 3.0.3

data/spec/engineyard-serverside/callbacks/distributor_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'result'
+require 'engineyard-serverside/callbacks/distributor'
+
+module EY
+  module Serverside
+    module Callbacks
+
+      describe Distributor do
+
+        describe '.distribute' do
+          let(:runner) {Object.new}
+          let(:shell) {Object.new}
+          let(:hook_name) {:some_hook}
+          let(:failure) {Result::Failure.new({})}
+          let(:success) {Result::Success.new(hook_name)}
+
+          let(:result) {described_class.distribute(runner, hook_name)}
+
+          before(:each) do
+            allow(described_class::Remote).to receive(:distribute)
+
+            allow(runner).to receive(:shell).and_return(shell)
+          end
+
+          it 'distributes the hook remotely' do
+            expect(described_class::Remote).
+              to receive(:distribute).
+              with(runner, hook_name)
+
+            result
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/spec/engineyard-serverside/callbacks/executor/executable_spec.rb

@@ -0,0 +1,386 @@
+require 'spec_helper'
+require 'escape'
+
+require 'result'
+
+require 'engineyard-serverside/callbacks/executor/executable'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Executor
+
+        describe Executable do
+          let(:config) {Object.new}
+          let(:shell) {Object.new}
+          let(:paths) {Object.new}
+          let(:hook) {Object.new}
+          let(:short_name) {'hook'}
+          let(:active_release_path) {'/path/to/the/active/release'}
+          let(:hook_path) {'/path/to/the/dang/hook'}
+          let(:account_name) {'george'}
+          let(:app) {'tacoma'}
+          let(:env_name) {'gracie'}
+          let(:framework_env) {'sausages'}
+          let(:current_roles) {['hamlet', 'ophelia']}
+          let(:current_name) {nil}
+          let(:config_json) {'a big ol hash'}
+          let(:verbose) {false}
+          let(:execution_success) {true}
+          let(:hook_string) {'hooky'}
+
+          let(:executor) {described_class.new(config, shell, hook)}
+
+          before(:each) do
+            allow(hook).to receive(:path).and_return(hook_path)
+            allow(hook).to receive(:short_name).and_return(short_name)
+            allow(hook).to receive(:to_s).and_return(hook_string)
+            allow(hook).
+              to receive(:respond_to?).
+              with(:service_name).
+              and_return(false)
+
+            allow(shell).to receive(:info)
+            allow(shell).to receive(:fatal)
+            allow(shell).to receive(:warning)
+
+            allow(config).to receive(:paths).and_return(paths)
+            allow(config).to receive(:current_roles).and_return(current_roles)
+            allow(config).to receive(:account_name).and_return(account_name)
+            allow(config).to receive(:app).and_return(app)
+            allow(config).to receive(:environment_name).and_return(env_name)
+            allow(config).to receive(:verbose).and_return(verbose)
+            allow(config).to receive(:current_name).and_return(current_name)
+            allow(config).to receive(:framework_env).and_return(framework_env)
+            allow(config).to receive(:to_json).and_return(config_json)
+            allow(config).
+              to receive(:framework_envs).
+              and_return("RACK_ENV=#{framework_env} RAILS_ENV=#{framework_env}")
+
+
+            allow(paths).to receive(:active_release).and_return(active_release_path)
+            allow(hook_path).to receive(:executable?).and_return(true)
+
+            # This is a wee bit dirty, but the easiest way to test our actual code
+            # here is to stub out the included Runner interface.
+            allow(executor).to receive(:run) do |cmd|
+              EY::Serverside::Spawner::Result.new(cmd, execution_success, cmd, nil)
+            end
+
+            # We also need to stub out the #abort method, as we don't need the
+            # test suite to just up and stop running when we test executor failure
+            # modes.
+            allow(executor).to receive(:abort)
+          end
+
+          it 'is a Railway' do
+            expect(executor).to be_a(Railway)
+          end
+
+          it 'knows how to spawn CLI processes' do
+            expect(executor).to be_a(Runner)
+          end
+
+          it 'has the exact steps for executing a Ruby hook' do
+            steps = described_class.steps.map {|s| s[:name]}
+
+            expect(steps).to eql(
+              [
+                :validate_hook,
+                :populate_environment,
+                :calculate_wrapper,
+                :run_hook
+              ]
+            )
+          end
+
+          describe '#validate_hook' do
+            let(:input) {
+              {}
+            }
+
+            let(:result) {executor.validate_hook}
+
+            context 'when the hook has the executable bit' do
+              before(:each) do
+                allow(hook_path).to receive(:executable?).and_return(true)
+              end
+
+              it 'is a Success' do
+                expect(result).to be_a(Result::Success)
+              end
+
+              it 'does not alter the input' do
+                expect(result.value).to eql(input)
+              end
+            end
+
+            context 'when the hook lacks the executable bit' do
+              before(:each) do
+                allow(hook_path).to receive(:executable?).and_return(false)
+              end
+
+              it 'is a Failure' do
+                expect(result).to be_a(Result::Failure)
+              end
+
+              it 'contains a reason for the failure' do
+                expect(result.error[:reason]).to eql(:not_executable)
+              end
+            end
+          end
+
+          describe '#populate_environment' do
+            let(:input) {{}}
+
+            let(:result) {executor.populate_environment(input)}
+            let(:result_env) {result.value[:environment]}
+
+            it 'is a Success' do
+              expect(result).to be_a(Result::Success)
+            end
+
+            it 'adds the environment to the input' do
+              expect(result_env).to be_a(String)
+            end
+
+            it 'includes the account name in the environment' do
+              escaped = Escape.shell_command([account_name])
+
+              expect(result_env).
+                to match(%r{EY_DEPLOY_ACCOUNT_NAME=#{escaped}})
+            end
+
+            it 'includes the application in the environment' do
+              escaped = Escape.shell_command([app])
+
+              expect(result_env).
+                to match(%{EY_DEPLOY_APP=#{escaped}})
+            end
+
+            it 'includes the JSON representation of the config in the environment' do
+              escaped = Escape.shell_command([config_json])
+
+              expect(result_env).
+                to match(%r{EY_DEPLOY_CONFIG=#{escaped}})
+            end
+
+            it 'includes all of the current roles in the environment' do
+              expect(result_env).
+                to match(%r{EY_DEPLOY_CURRENT_ROLES='#{current_roles.join(' ')}'})
+            end
+
+            context 'when the server is named' do
+              let(:current_name) {'frankie'}
+              let(:escaped) {Escape.shell_command([current_name])}
+
+              it 'includes the current server name' do
+                expect(result_env).
+                  to match(%r{EY_DEPLOY_CURRENT_NAME=#{escaped}})
+              end
+            end
+
+            context 'when the server is unnamed' do
+              let(:current_name) {nil}
+
+              it 'omits the current server name' do
+                expect(result_env).
+                  not_to match(%r{EY_DEPLOY_CURRENT_NAME})
+              end
+            end
+
+            it 'includes the environment name in the environment' do
+              escaped = Escape.shell_command([env_name])
+
+              expect(result_env).
+                to match(%r{EY_DEPLOY_ENVIRONMENT_NAME=#{escaped}})
+            end
+
+            it 'includes the framwork env in the environment' do
+              escaped = Escape.shell_command([framework_env])
+
+              expect(result_env).
+                to match(%r{EY_DEPLOY_FRAMEWORK_ENV=#{escaped}})
+            end
+
+            it 'includes the release path in the environment' do
+              escaped = Escape.shell_command([active_release_path])
+
+              expect(result_env).
+                to match(%r{EY_DEPLOY_RELEASE_PATH=#{escaped}})
+            end
+
+            context 'with verbosity configured' do
+              let(:verbose) {true}
+
+              it 'enables verbosity in the environment' do
+                expect(result.value[:environment]).
+                  to match(%r{EY_DEPLOY_VERBOSE=1})
+              end
+            end
+
+            context 'without verbosity configured' do
+              let(:verbose) {false}
+
+              it 'disables verbosity in the environment' do
+                expect(result.value[:environment]).
+                  to match(%r{EY_DEPLOY_VERBOSE=0})
+              end
+            end
+
+            context 'when any of the values involved are nil' do
+              let(:account_name) {nil}
+              let(:app) {nil}
+              let(:config_json) {nil}
+              let(:env_name) {nil}
+
+              it 'omits those env vars' do
+                affected = ['ACCOUNT_NAME', 'APP', 'CONFIG', 'ENVIRONMENT_NAME']
+
+                affected.each do |var|
+                  expect(result_env).not_to match(%r{EY_DEPLOY_#{var}})
+                end
+              end
+
+            end
+
+          end
+
+          describe '#calculate_wrapper' do
+            let(:input) {{}}
+
+            let(:result) {executor.calculate_wrapper(input)}
+
+            it 'is a Success' do
+              expect(result).to be_a(Result::Success)
+            end
+
+            it 'adds a wrapper to the input' do
+              expect(result.value[:wrapper]).not_to be_nil
+            end
+
+            context 'when dealing with a service hook' do
+              before(:each) do
+                allow(hook).
+                  to receive(:respond_to?).
+                  with(:service_name).
+                  and_return(true)
+              end
+
+              it 'wraps the service hook executor' do
+                expect(result.value[:wrapper]).to eql(About.service_hook_executor)
+              end
+            end
+
+            context 'when dealing with an app hook' do
+              before(:each) do
+                allow(hook).
+                  to receive(:respond_to?).
+                  with(:service_name).
+                  and_return(false)
+              end
+
+              it 'wraps the app hook executor' do
+                expect(result.value[:wrapper]).to eql(About.hook_executor)
+              end
+            end
+          end
+
+          describe '#run_hook' do
+            let(:dummy_env) {'i am an environment'}
+            let(:wrapper) {'candy-bar'}
+            let(:input) {
+              {
+                :wrapper => wrapper,
+                :environment => dummy_env
+              }
+            }
+
+            let(:result) {executor.run_hook(input)}
+
+            it 'runs the proper command' do
+              expect(executor).
+                to receive(:run).
+                with(
+                  "#{dummy_env} #{config.framework_envs} #{wrapper} #{short_name}"
+                )
+
+              result
+            end
+
+            context 'when the execution succeeds' do
+              let(:execution_success) {true}
+
+              it 'is a Success' do
+                expect(result).to be_a(Result::Success)
+              end
+
+              it 'does not alter the input' do
+                expect(result.value).to eql(input)
+              end
+            end
+
+            context 'when the execution fails' do
+              let(:execution_success) {false}
+
+              it 'is a Failure' do
+                expect(result).to be_a(Result::Failure)
+              end
+
+              it 'has exeuction failure as its reason' do
+                expect(result.error[:reason]).to eql(:execution_failed)
+              end
+            end
+          end
+
+          describe '#handle_failure' do
+            let(:reason) {nil}
+            let(:error) {
+              {
+                :reason => reason
+              }
+            }
+
+            let(:result) {executor.handle_failure(error)}
+
+            context 'when the hook is not actually executable' do
+              let(:reason) {:not_executable}
+
+              it 'does nothing and returns true' do
+                expect(result).to eql(true)
+              end
+            end
+
+            context 'when execution of the hook fails' do
+              let(:reason) {:execution_failed}
+
+              it 'aborts with a message about the execution failure' do
+                expect(executor).
+                  to receive(:abort).
+                  with(
+                    "*** [Error] Hook failed to exit cleanly: #{hook_path} ***\n"
+                  )
+
+                result
+              end
+            end
+
+            context 'when an otherwise unexpected error occurs' do
+              let(:reason) {nil}
+
+              it 'aborts with a message about the unknown error' do
+                expect(executor).
+                  to receive(:abort).
+                  with("*** [Error] An unknown error occurred for hook: #{hook_path} ***\n")
+
+                result
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/callbacks/executor/ruby/context_spec.rb

@@ -0,0 +1,538 @@
+require 'spec_helper'
+
+require 'escape'
+
+require 'engineyard-serverside/callbacks/executor/ruby/context'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Executor
+        module Ruby
+
+          describe Context do
+            let(:config) {
+              Class.new do
+                def two_minus_one
+                  1
+                end
+              end.new
+            }
+
+            let(:shell) {Object.new}
+            let(:paths) {Object.new}
+            let(:hook) {Object.new}
+            let(:hook_path) {'/path/to/the/dang/hook.rb'}
+            let(:current_roles) {['hamlet', 'ophelia']}
+            let(:node) {Object.new}
+            let(:active_release_path) {'/path/to/the/release'}
+            let(:execution_success) {true}
+
+            let(:context) {described_class.new(config, shell, hook)}
+
+            before(:each) do
+              allow(hook).to receive(:path).and_return(hook_path)
+
+              allow(shell).to receive(:info)
+              allow(shell).to receive(:fatal)
+              allow(shell).to receive(:warning)
+              allow(shell).to receive(:logged_system) do |cmd|
+                EY::Serverside::Spawner::Result.new(
+                  cmd,
+                  execution_success,
+                  cmd,
+                  nil
+                )
+              end
+
+              allow(config).to receive(:paths).and_return(paths)
+              allow(config).to receive(:set_framework_envs)
+              allow(config).to receive(:node).and_return(node)
+              allow(config).to receive(:current_roles).and_return(current_roles)
+
+              allow(paths).
+                to receive(:active_release).
+                and_return(active_release_path)
+            end
+
+            describe '#inspect' do
+              let(:result) {context.inspect}
+
+              it 'is a string' do
+                expect(result).to be_a(String)
+              end
+
+              it 'includes the context namespace path' do
+                expect(result).to match(%r{Callbacks::Executor::Ruby::Context})
+              end
+
+              it 'includes the path to the hook' do
+                expect(result).to match(%{#{hook_path.inspect}})
+              end
+
+              it 'looks like a typical inspect result' do
+                expect(result).to match(%{^#<.*>$})
+              end
+            end
+
+            describe '#config' do
+              it 'is the configuration object for the context' do
+                expect(context.config).to eql(context.config)
+              end
+            end
+
+            describe '#method_missing' do
+              context 'for config methods' do
+                let(:result) {context.two_minus_one}
+
+                it 'warns about deprecated missing_method reliance' do
+                  expect(shell).to receive(:warning).with("Use of `two_minus_one` (via method_missing) is deprecated in favor of `config.two_minus_one` for improved error messages and compatibility.\n\tin #{hook_path}")
+
+                  result
+                end
+
+                it 'passes the call along to config' do
+                  expect(config).to receive(:two_minus_one).and_return(3)
+
+                  expect(result).to eql(3)
+                end
+              end
+
+              context 'for non-config methods' do
+                let(:result) {context.two_minus_two}
+
+                it 'eventually raises an error' do
+                  expect {result}.to raise_error
+                end
+
+              end
+            end
+
+            describe '#respond_to?' do
+              let(:meth) {:class}
+
+              let(:result) {context.respond_to?(meth)}
+
+              context 'when given a config method' do
+                let(:meth) {:two_minus_one}
+
+                it 'is true' do
+                  expect(result).to eql(true)
+                end
+              end
+
+              context 'when given a non-config method' do
+                context 'that context knows how to handle' do
+                  let(:meth) {:run}
+
+                  it 'is true' do
+                    expect(result).to eql(true)
+                  end
+                end
+
+                context 'that context does not know how to handle' do
+                  let(:meth) {:walk}
+
+                  it 'is false' do
+                    expect(result).to eql(false)
+                  end
+                end
+              end
+            end
+
+            describe '#run' do
+              let(:cmd) {'touch yournose'}
+              let(:result) {context.run(cmd)}
+
+              it 'runs the wrapped command via the shell with logging' do
+                expect(shell).
+                  to receive(:logged_system).
+                  with("sh -l -c 'touch yournose'")
+
+                result
+              end
+
+              context 'when the command succeeds' do
+                let(:execution_success) {true}
+
+                it 'is false' do
+                  expect(result).to eql(true)
+                end
+              end
+
+              context 'when the command fails' do
+                let(:execution_success) {false}
+
+                it 'is false' do
+                  expect(result).to eql(false)
+                end
+              end
+            end
+
+            describe '#run!' do
+              let(:cmd) {'touch yourtoes'}
+              let(:result) {context.run!(cmd)}
+
+              it 'runs the command' do
+                expect(context).to receive(:run).with(cmd).and_return(true)
+
+                result
+              end
+
+              context 'when the command succeeds' do
+                let(:execution_success) {true}
+
+                it 'is true' do
+                  expect(result).to eql(true)
+                end
+              end
+
+              context 'when the command fails' do
+                let(:execution_success) {false}
+
+                it 'raises an error' do
+                  expect {result}.to raise_error("run!: Command failed. #{cmd}")
+                end
+              end
+            end
+
+            describe '#sudo' do
+              let(:cmd) {'touch yournose'}
+              let(:result) {context.sudo(cmd)}
+
+              it 'runs the sudo-wrapped command via the shell with logging' do
+                expect(shell).
+                  to receive(:logged_system).
+                  with("sudo sh -l -c 'touch yournose'")
+
+                result
+              end
+
+              context 'when the command succeeds' do
+                let(:execution_success) {true}
+
+                it 'is false' do
+                  expect(result).to eql(true)
+                end
+              end
+
+              context 'when the command fails' do
+                let(:execution_success) {false}
+
+                it 'is false' do
+                  expect(result).to eql(false)
+                end
+              end
+            end
+
+
+            describe '#sudo!' do
+              let(:cmd) {'touch yourtoes'}
+              let(:result) {context.sudo!(cmd)}
+
+              it 'sudo runs the command' do
+                expect(context).to receive(:sudo).with(cmd).and_return(true)
+
+                result
+              end
+
+              context 'when the command succeeds' do
+                let(:execution_success) {true}
+
+                it 'is true' do
+                  expect(result).to eql(true)
+                end
+              end
+
+              context 'when the command fails' do
+                let(:execution_success) {false}
+
+                it 'raises an error' do
+                  expect {result}.to raise_error("sudo!: Command failed. #{cmd}")
+                end
+              end
+            end
+
+            describe '#on_app_master' do
+              let(:dummy) {Object.new}
+              let(:result) {context.on_app_master {dummy.process}}
+
+              before(:each) do
+                allow(dummy).to receive(:process)
+              end
+
+              context 'on a solo instance' do
+                let(:current_roles) {['solo']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on an app master instance' do
+                let(:current_roles) {['app_master']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on an app instance' do
+                let(:current_roles) {['app']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a util instance' do
+                let(:current_roles) {['util']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a database master instance' do
+                let(:current_roles) {['db_master']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a database replicant instance' do
+                let(:current_roles) {['db_slave']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+            end
+
+            describe '#on_app_servers' do
+              let(:dummy) {Object.new}
+              let(:result) {context.on_app_servers {dummy.process}}
+
+              before(:each) do
+                allow(dummy).to receive(:process)
+              end
+
+              context 'on a solo instance' do
+                let(:current_roles) {['solo']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on an app master instance' do
+                let(:current_roles) {['app_master']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on an app instance' do
+                let(:current_roles) {['app']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a util instance' do
+                let(:current_roles) {['util']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a database master instance' do
+                let(:current_roles) {['db_master']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a database replicant instance' do
+                let(:current_roles) {['db_slave']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+            end
+
+            describe '#on_app_servers_and_utilities' do
+              let(:dummy) {Object.new}
+              let(:result) {context.on_app_servers_and_utilities {dummy.process}}
+
+              before(:each) do
+                allow(dummy).to receive(:process)
+              end
+
+              context 'on a solo instance' do
+                let(:current_roles) {['solo']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on an app master instance' do
+                let(:current_roles) {['app_master']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on an app instance' do
+                let(:current_roles) {['app']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a util instance' do
+                let(:current_roles) {['util']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a database master instance' do
+                let(:current_roles) {['db_master']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a database replicant instance' do
+                let(:current_roles) {['db_slave']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+            end
+
+            describe '#on_utilities' do
+              let(:dummy) {Object.new}
+              let(:result) {context.on_utilities {dummy.process}}
+
+              before(:each) do
+                allow(dummy).to receive(:process)
+              end
+
+              context 'on a solo instance' do
+                let(:current_roles) {['solo']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on an app master instance' do
+                let(:current_roles) {['app_master']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on an app instance' do
+                let(:current_roles) {['app']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a util instance' do
+                let(:current_roles) {['util']}
+
+                it 'runs the given block' do
+                  expect(dummy).to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a database master instance' do
+                let(:current_roles) {['db_master']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+
+              context 'on a database replicant instance' do
+                let(:current_roles) {['db_slave']}
+
+                it 'skips the given block' do
+                  expect(dummy).not_to receive(:process)
+
+                  result
+                end
+              end
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end