engineyard-serverside 2.8.0.pre → 3.0.3

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

@@ -0,0 +1,313 @@
+require 'spec_helper'
+
+require 'result'
+
+require 'engineyard-serverside/callbacks/executor/ruby/executor'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Executor
+
+        module Ruby
+          describe Executor do
+            let(:config) {Object.new}
+            let(:shell) {Object.new}
+            let(:paths) {Object.new}
+            let(:hook) {Object.new}
+            let(:active_release_path) {'/path/to/the/active/release'}
+            let(:hook_path) {'/path/to/the/dang/hook.rb'}
+            let(:hook_content) {
+              'puts "My sausages turned to gold!"'
+            }
+            let(:syntax_error) {'OMG what bad syntax'}
+
+            let(:executor) {described_class.new(config, shell, hook)}
+
+            before(:each) do
+              allow(hook).to receive(:path).and_return(hook_path)
+              allow(hook).to receive(:read).and_return(hook_content)
+
+              allow(shell).to receive(:info)
+              allow(shell).to receive(:fatal)
+              allow(shell).to receive(:warning)
+
+              allow(config).to receive(:paths).and_return(paths)
+
+              allow(paths).to receive(:active_release).and_return(active_release_path)
+            end
+
+            it 'is a Railway' do
+              expect(executor).to be_a(Railway)
+            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,
+                  :display_deprecation_warnings,
+                  :announce_execution,
+                  :context_eval
+                ]
+              )
+            end
+
+            describe '#validate_hook' do
+              let(:input) {
+                {}
+              }
+
+              let(:result) {executor.validate_hook}
+
+              context 'when ruby reports good syntax' do
+                before(:each) do
+                  allow(executor).
+                    to receive(:`).
+                    and_return('Syntax OK')
+                end
+
+                it 'is a Success' do
+                  expect(result).to be_a(Result::Success)
+                end
+
+                it 'contains the hook code' do
+                  expect(result.value[:code]).to eql(hook_content)
+                end
+              end
+
+              context 'when ruby reports bad syntax' do
+                before(:each) do
+                  allow(executor).
+                    to receive(:`).
+                    and_return(syntax_error)
+                end
+
+                it 'is a failure' do
+                  expect(result).to be_a(Result::Failure)
+                end
+
+                it 'the reason for the failure is a syntax error' do
+                  expect(result.error[:reason]).to eql(:syntax_error)
+                end
+
+                it 'contains the actual syntax error' do
+                  expect(result.error[:syntax_error]).to eql(syntax_error)
+                end
+
+              end
+            end
+
+            describe '#display_deprecation_warnings' do
+              let(:input) {
+                {
+                  :code => hook_content
+                }
+              }
+
+              let(:result) {executor.display_deprecation_warnings(input)}
+
+              context 'when there are @configuration references in the hook' do
+                let(:hook_content) {'@configuration == "my jam"'}
+                let(:warning_message) {
+                  "Use of `@configuration` in deploy hooks is deprecated.\nPlease use `config`, which provides access to the same object.\n\tin #{hook_path}"
+                }
+
+                it 'prints a warning regarding that usage' do
+                  expect(shell).
+                    to receive(:warning).
+                    with(warning_message)
+
+                  result
+                end
+              end
+
+              context 'when there are @node references in the hook' do
+                let(:hook_content) {'@node == "my jam"'}
+                let(:warning_message) {
+                  "Use of `@node` in deploy hooks is deprecated.\nPlease use `config.node`, which provides access to the same object.\n\tin #{hook_path}"
+                }
+
+                it 'prints a warning regarding that usage' do
+                  expect(shell).
+                    to receive(:warning).
+                    with(warning_message)
+
+                  result
+                end
+              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
+
+            describe '#announce_execution' do
+              let(:input) {
+                {
+                  :code => hook_content
+                }
+              }
+
+              let(:result) {executor.announce_execution(input)}
+
+              it 'lets the user know that the hook is being executed' do
+                expect(shell).to receive(:info).with("Executing #{hook_path} ...")
+
+                result
+              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
+
+            describe '#context_eval' do
+              let(:ruby_context) {Object.new}
+              let(:input) {
+                {
+                  :code => hook_content
+                }
+              }
+
+              let(:result) {executor.context_eval(input)}
+
+              before(:each) do
+                allow(Dir).to receive(:chdir).and_yield
+
+                allow(Context).
+                  to receive(:new).
+                  and_return(ruby_context)
+
+                allow(ruby_context).to receive(:instance_eval)
+              end
+
+              it 'switches to the active release directory' do
+                expect(Dir).to receive(:chdir).with(active_release_path).and_yield
+
+                result
+              end
+
+              it 'attempts to execute the hook via a new context' do
+                expect(ruby_context).to receive(:instance_eval).with(hook_content)
+
+                result
+              end
+
+              context 'when the hook executes without issue' do
+                it 'is a Success' do
+                  expect(result).to be_a(Result::Success)
+                end
+
+                it 'does not modify its input' do
+                  expect(result.value).to eql(input)
+                end
+              end
+
+              context 'when the hook raises an exception' do
+                let(:exception_message) {'nine kinds of calamity'}
+
+                before(:each) do
+                  allow(ruby_context).
+                    to receive(:instance_eval).
+                    with(hook_content).
+                    and_raise(exception_message)
+                end
+
+                it 'is a Failure' do
+                  expect(result).to be_a(Result::Failure)
+                end
+
+                it 'has a failed execution reason' do
+                  expect(result.error[:reason]).to eql(:execution_failed)
+                end
+
+                it 'includes the raised exception' do
+                  expect(result.error[:exception].to_s).
+                    to eql(exception_message)
+                end
+              end
+            end
+
+            describe '#handle_failure' do
+              let(:reason) {nil}
+              let(:exception) {nil}
+
+              let(:payload) {
+                {
+                  :code => hook_content,
+                  :reason => reason,
+                  :exception => exception,
+                  :syntax_error => syntax_error
+                }
+              }
+
+              let(:result) {executor.handle_failure(payload)}
+
+              before(:each) do
+                allow(executor).to receive(:abort)
+              end
+
+              context 'when the failure was due to a failed execution' do
+                let(:exception_message) {'cats have cute little nosies'}
+                let(:exception) {RuntimeError.new(exception_message)}
+                let(:reason) {:execution_failed}
+
+                it 'logs the exception' do
+                  expect(shell).to receive(:fatal).with("  Exception raised in hook #{hook_path}.\n\n  RuntimeError: #{exception_message}\n\n  Please fix this error before retrying.\n")
+
+                  begin
+                    result
+                  rescue
+                  end
+                end
+
+                it 're-raises the exception' do
+                  expect {result}.to raise_exception(exception)
+                end
+              end
+
+              context 'when the failure was due to a syntax error' do
+                let(:reason) {:syntax_error}
+                let(:abort_message) {
+                  "*** [Error] Invalid Ruby syntax in hook: #{hook_path} ***\n*** #{syntax_error} ***"
+                }
+
+                it 'aborts with a message regarding the syntax error' do
+                  expect(executor).to receive(:abort).with(abort_message)
+
+                  result
+                end
+              end
+
+              context 'when the failure was due to some unknown problem' do
+                let(:reason) {nil}
+                let(:abort_message) {
+                  "*** [Error] An unknown error occurred for hook: #{hook_path} ***"
+                }
+
+                it 'abors with a message regarding the unknown error' do
+                  expect(executor).to receive(:abort).with(abort_message)
+
+                  result
+                end
+
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+require 'result'
+
+require 'engineyard-serverside/callbacks/executor/ruby'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Executor
+
+        describe Ruby do
+          let(:config) {Object.new}
+          let(:shell) {Object.new}
+          let(:hook) {Object.new}
+
+          describe '.execute' do
+            let(:result) {described_class.execute(config, shell, hook)}
+
+            it 'forwards the execution to a ruby executor' do
+              expect(described_class::Executor).
+                to receive(:execute).
+                with(config, shell, hook)
+
+              result
+            end
+
+          end
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'result'
+require 'engineyard-serverside/callbacks/executor'
+
+module EY
+  module Serverside
+    module Callbacks
+
+      describe Executor do
+        let(:config) {Object.new}
+        let(:shell) {Object.new}
+        let(:ruby_hook) {Object.new}
+        let(:executable_hook) {Object.new}
+        let(:hooks) {[ruby_hook, executable_hook]}
+
+        before(:each) do
+          allow(ruby_hook).to receive(:flavor).and_return(:ruby)
+          allow(executable_hook).to receive(:flavor).and_return(:executable)
+        end
+
+        describe '.execute' do
+          let(:result) {described_class.execute(config, shell, hooks)}
+
+          it 'dispatches each hook to the proper executor' do
+            expect(described_class::Ruby).
+              to receive(:execute).
+              with(config, shell, ruby_hook)
+
+            expect(described_class::Executable).
+              to receive(:execute).
+              with(config, shell, executable_hook)
+
+            result
+          end
+
+        end
+      end
+
+    end
+  end
+end
+

data/spec/engineyard-serverside/callbacks_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/callbacks'
+
+module EY
+  module Serverside
+    describe Callbacks do
+      describe '.load' do
+        let(:paths) {Object.new}
+        let(:collection) {Object.new}
+        let(:result) {described_class.load(paths)}
+
+        before(:each) do
+          allow(described_class::Collection).
+            to receive(:load).
+            and_return(collection)
+        end
+
+        it 'loads a collection' do
+          expect(described_class::Collection).to receive(:load).with(paths)
+
+          result
+        end
+
+        it 'is a callbacks collection' do
+          expect(result).to eql(collection)
+        end
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/cli/workflows/base_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/cli/workflows/base'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+        describe Base do
+          let(:shell) {Object.new}
+          let(:config) {Object.new}
+          let(:options) {{}}
+          let(:workflow) {described_class.new(options)}
+
+          before(:each) do
+            # Both the Shell and Deploy::Configuration classes are used in
+            # the Workflow private API. However, since we're not actually
+            # testing their behavior (nor that of an actual workflow) here,
+            # we'll need to make sure that we can use them in a predictable
+            # way.
+            allow(EY::Serverside::Shell).
+              to receive(:new).
+              and_return(shell)
+
+            allow(EY::Serverside::Deploy::Configuration).
+              to receive(:new).
+              and_return(config)
+
+            allow(shell).to receive(:fatal)
+            allow(shell).to receive(:debug)
+
+            allow(config).to receive(:verbose)
+            allow(config).to receive(:app)
+          end
+
+          describe '#options' do
+            it 'is the options passed in during creation' do
+              expect(workflow.options).to eql(options)
+            end
+          end
+
+          describe '#perform' do
+            let(:perform) {workflow.perform}
+
+            before(:each) do
+              # Technically, this is against the rules, because I'm stubbing
+              # methods on the object under test. They're private methods,
+              # though, so I reckon that's probably acceptable.
+              allow(workflow).to receive(:procedure)
+              allow(workflow).to receive(:task_name)
+            end
+
+            it 'announces the serverside init' do
+              expect(shell).
+                to receive(:debug).
+                with("Initializing #{EY::Serverside::About.name_with_version}.")
+
+              perform
+            end
+
+            it 'calls its internal procedure' do
+              expect(workflow).to receive(:procedure)
+
+              perform
+            end
+
+            context 'when the procedure raises a remote failure' do
+              let(:error_message) {'onoes'}
+
+              before(:each) do
+                allow(workflow).
+                  to receive(:procedure).
+                  and_raise(EY::Serverside::RemoteFailure.new(error_message))
+
+              end
+
+              it 'logs a fatal error and re-raises' do
+                expect(shell).to receive(:fatal).with(error_message)
+
+                expect {perform}.to raise_error(EY::Serverside::RemoteFailure)
+              end
+            end
+
+            context 'when the procedure raises an unhandled exception' do
+              let(:error_message) {'the system is down'}
+              let(:exception) {Exception.new(error_message)}
+
+              before(:each) do
+                allow(workflow).
+                  to receive(:procedure).
+                  and_raise(exception)
+
+                # Apparently, instantiating an exception in specs gets a bit
+                # wonky.
+                allow(exception).to receive(:backtrace).and_return(['darn'])
+              end
+
+              it 'logs a fatal error and re-raises' do
+                expect(shell).
+                  to receive(:fatal).
+                  with("#{exception.backtrace[0]}: #{exception.message} (#{exception.class})")
+
+                expect {perform}.to raise_error(exception)
+              end
+            end
+
+          end
+
+          describe '.perform' do
+            let(:dummy) {Object.new}
+            let(:perform) {described_class.perform(options)}
+
+            it 'calls #perform on a new instance' do
+              expect(described_class).
+                to receive(:new).
+                with(options).
+                and_return(dummy)
+
+              expect(dummy).to receive(:perform)
+
+              perform
+            end
+          end
+
+          context 'private API' do
+            describe '#procedure' do
+              let(:procedure) {workflow.instance_eval {procedure}}
+
+              it 'must be defined in a subclass' do
+                expect {procedure}.
+                  to raise_error(
+                    Undefined,
+                    "You must define the private procedure method for your workflow."
+                )
+              end
+            end
+
+            describe '#task_name' do
+              let(:task_name) {workflow.instance_eval {task_name}}
+
+              it 'must be defined in a subclass' do
+                expect {task_name}.
+                  to raise_error(
+                    Undefined,
+                    "You must define the private task_name method for your workflow."
+                )
+              end
+            end
+
+            describe '#config' do
+              it 'is a Deploy Configuration for our options' do
+                expect(EY::Serverside::Deploy::Configuration).
+                  to receive(:new).
+                  with(options).
+                  and_return(config)
+
+                expect(workflow.instance_eval {config}).to eql(config)
+              end
+            end
+
+            describe '#shell' do
+              before(:each) do
+                allow(config).to receive(:app).and_return('denied')
+                allow(workflow).to receive(:task_name).and_return('george')
+              end
+
+              it 'is a Shell' do
+                expect(EY::Serverside::Shell).
+                  to receive(:new).
+                  with(
+                    :verbose => config.verbose,
+                    :log_path => File.join(
+                      ENV['HOME'],
+                      "#{config.app}-#{workflow.instance_eval {task_name}}.log"
+                    )
+                  ).
+                  and_return(shell)
+
+                expect(workflow.instance_eval {shell}).to eql(shell)
+              end
+            end
+
+            describe '#servers' do
+              let(:server_hashes) {[]}
+              let(:collection) {Object.new}
+              let(:servers) {workflow.instance_eval {servers}}
+
+              before(:each) do
+                allow(workflow).to receive(:task_name)
+              end
+
+              it 'is the servers applicable to the workflow' do
+                expect(EY::Serverside::CLI::ServerHashExtractor).
+                  to receive(:hashes).
+                  with(options, config).
+                  and_return(server_hashes)
+
+                expect(EY::Serverside::Servers).
+                  to receive(:from_hashes).
+                  with(server_hashes, shell).
+                  and_return(collection)
+
+                expect(servers).to eql(collection)
+              end
+            end
+
+            describe '#propagate_serverside' do
+              let(:servers) {Object.new}
+
+              let(:propagate_serverside) {
+                workflow.instance_eval {propagate_serverside}
+              }
+
+              before(:each) do
+                allow(workflow).to receive(:task_name)
+              end
+
+              it 'propagates engineyard-serverside to the workflow servers' do
+                expect(workflow).to receive(:servers).and_return(servers)
+
+                expect(EY::Serverside::Propagator).
+                  to receive(:propagate).
+                  with(servers, shell)
+
+                propagate_serverside
+              end
+            end
+
+
+
+          end
+
+        end
+      end
+    end
+  end
+end