engineyard-serverside 2.8.0.pre4 → 2.8.0

data/spec/engineyard-serverside/callbacks/collection/service_hooks_spec.rb

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

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'engineyard-serverside/callbacks/collection'
+
+module EY
+  module Serverside
+    module Callbacks
+
+      describe Collection do
+        let(:paths) {Object.new}
+        let(:deploy_hooks) {described_class::DeployHooks}
+        let(:service_hooks) {described_class::ServiceHooks}
+
+        before(:each) do
+          allow(deploy_hooks).
+            to receive(:load).
+            with(paths)
+
+          allow(service_hooks).
+            to receive(:load).
+            with(paths)
+        end
+
+        describe '.load' do
+          let(:result) {described_class.load(paths)}
+
+          it 'loads deploy hooks' do
+            expect(deploy_hooks).to receive(:load).with(paths)
+
+            result
+          end
+
+          it 'loads service hooks' do
+            expect(service_hooks).to receive(:load).with(paths)
+
+            result
+          end
+
+          it 'is a combined callbacks collection' do
+            expect(result).to be_a(described_class::Combined)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/engineyard-serverside/callbacks/distributor/remote_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+require 'pathname'
+require 'escape'
+
+require 'engineyard-serverside/callbacks/distributor/remote'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Distributor
+
+        describe Remote do
+          let(:runner) {Object.new}
+          let(:callback_name) {:some_callback}
+          let(:shell) {Object.new}
+          let(:config) {Object.new}
+          let(:paths) {Object.new}
+          let(:app) {'some_app'}
+          let(:account_name) {'some_account'}
+          let(:config_json) {'i am a json config'}
+          let(:environment_name) {'some_environment'}
+          let(:framework_env) {'some_framework_env'}
+          let(:verbose) {nil}
+          let(:active_release) {'/data/some_app/releases/123456789'}
+          let(:server) {Object.new}
+          let(:server_name) {nil}
+          let(:roles) {[:hamlet, :ophelia]}
+          let(:cmd) {'some command'}
+
+          let(:distributor) {described_class.new(runner, callback_name)}
+
+          before(:each) do
+            # Stub out the parts of the runner interface that we use
+            allow(runner).to receive(:shell).and_return(shell)
+            allow(runner).to receive(:run).and_yield(server, cmd)
+            allow(runner).to receive(:config).and_return(config)
+            allow(runner).to receive(:paths).and_return(paths)
+
+            # Stub out the parts of the shell interface that we use
+            allow(shell).to receive(:status)
+
+            # Stub out the parts of the config interface that we use
+            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(environment_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(:verbose).and_return(verbose)
+
+            # Stub out the parts of the paths interface that we use
+            allow(paths).to receive(:active_release).and_return(active_release)
+
+            # Stub out the parts of the server interface that we use
+            allow(server).to receive(:roles).and_return(roles)
+            allow(server).to receive(:name).and_return(server_name)
+          end
+
+          describe '.distribute' do
+            let(:result) {described_class.distribute(runner, callback_name)}
+
+            it 'uses a new distributor to distribute the hook' do
+              distributor = Object.new
+
+              expect(described_class).
+                to receive(:new).
+                with(runner, callback_name).
+                and_return(distributor)
+
+              expect(distributor).to receive(:distribute)
+
+              result
+            end
+          end
+
+          describe '#distribute' do
+            let(:result) {distributor.distribute}
+
+            it 'runs the escaped command for the callback' do
+              escaped_command = 'i am an escaped command'
+
+              expect(distributor).
+                to receive(:escaped_command).
+                and_return(escaped_command)
+
+              expect(runner).
+                to receive(:run).
+                with(escaped_command).
+                and_yield(server, escaped_command)
+
+              result
+            end
+
+            it 'announces that the hook is being run' do
+              expect(shell).
+                to receive(:status).
+                with("Running deploy hook: #{callback_name}")
+
+              result
+            end
+
+            it 'adds the escaped current roles flag' do
+              expect(result).to match(/--current-roles 'hamlet ophelia'/)
+            end
+
+            it 'adds the escaped config flag' do
+              expect(result).to match(/--config '#{config_json}'/)
+            end
+
+            context 'when the server has a name' do
+              let(:server_name) {'frank'}
+
+              it 'adds the current name flag' do
+                expect(result).to match(/--current-name #{server_name}/)
+              end
+            end
+
+            context 'when the server has a name' do
+              let(:server_name) {nil}
+
+              it 'omits the current name flag' do
+                expect(result).not_to match(/--current-name/)
+              end
+            end
+
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/spec/engineyard-serverside/callbacks/distributor/viability_filter_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'railway'
+require 'engineyard-serverside/callbacks/distributor/viability_filter'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Distributor
+
+        describe ViabilityFilter do
+          let(:shell) {Object.new}
+          let(:ruby_hook) {Object.new}
+          let(:executable_hook) {Object.new}
+          let(:executable_path) {Object.new}
+          let(:hooks) {[ruby_hook, executable_hook]}
+          let(:callback_name) {:some_callback}
+
+          let(:filter) {described_class.new}
+
+          before(:each) do
+            allow(ruby_hook).to receive(:flavor).and_return(:ruby)
+            allow(executable_hook).to receive(:flavor).and_return(:executable)
+            hooks.each do |hook|
+              allow(hook).to receive(:callback_name).and_return(callback_name)
+            end
+
+            allow(executable_hook).to receive(:path).and_return(executable_path)
+            allow(executable_path).to receive(:executable?).and_return(false)
+
+            allow(shell).to receive(:warning)
+          end
+
+          it 'is a Railway' do
+            expect(filter).to be_a(Railway)
+          end
+
+          it 'has the exact steps for filtering hooks' do
+            steps = described_class.steps.map {|s| s[:name]}
+
+            expect(steps).to eql(
+              [
+                :normalize_input,
+                :check_ruby_candidates,
+                :check_executable_candidates,
+                :calculate_callback_name
+              ]
+            )
+          end
+
+          describe '#normalize_input' do
+            let(:candidates) {hooks}
+
+            let(:input) {
+              {
+                :candidates => candidates,
+                :shell => shell
+              }
+            }
+
+            let(:result) {filter.normalize_input(input)}
+
+            it 'is always a success' do
+              expect(filter.normalize_input).to be_a(Result::Success)
+            end
+
+            it 'adds a viable array to the input hash' do
+              expect(result.value[:viable]).to be_a(Array)
+            end
+
+            context 'when given a non-array candidate' do
+              let(:candidates) {ruby_hook}
+
+              it 'converts the candidate to an array' do
+                expect(result.value[:candidates]).to eql([ruby_hook])
+              end
+            end
+          end
+
+          describe '#check_ruby_candidates' do
+            let(:input) {
+              {
+                :candidates => hooks,
+                :shell => shell,
+                :viable => []
+              }
+            }
+
+            let(:result) {filter.check_ruby_candidates(input)}
+
+            it 'adds all ruby hooks to the viable array' do
+              expect(result.value[:viable]).to include(ruby_hook)
+            end
+
+            it 'ignores non-ruby hooks' do
+              expect(result.value[:viable]).not_to include(executable_hook)
+            end
+
+            it 'does not alter the candidates' do
+              expect(result.value[:candidates]).to eql(hooks)
+            end
+          end
+
+          describe '#check_executable_candidates' do
+            let(:input) {
+              {
+                :candidates => hooks,
+                :shell => shell,
+                :viable => []
+              }
+            }
+
+            let(:result) {filter.check_executable_candidates(input)}
+
+            it 'ignores ruby hooks' do
+              expect(result.value[:viable]).not_to include(ruby_hook)
+            end
+
+            it 'does not alter the candidates' do
+              expect(result.value[:candidates]).to eql(hooks)
+            end
+
+            context 'with a hook that has the executable bit' do
+              before(:each) do
+                allow(executable_path).to receive(:executable?).and_return(true)
+              end
+
+              it 'adds that hook to the viable array' do
+                expect(result.value[:viable]).to include(executable_hook)
+              end
+            end
+
+            context 'with a hook that lacks the executable bit' do
+              before(:each) do
+                allow(executable_path).to receive(:executable?).and_return(false)
+              end
+
+              it 'warns the user that the hook is being skipped' do
+                expect(shell).
+                  to receive(:warning).
+                  with(
+                    "Skipping possible deploy hook #{executable_hook} because it is not executable."
+                  )
+
+                result
+              end
+
+              it 'omits that hook from the viable array' do
+                expect(result.value[:viable]).not_to include(executable_hook)
+              end
+            end
+          end
+
+          describe '#calculate_callback_name' do
+            let(:viable) {hooks}
+
+            let(:input) {
+              {
+                :candidates => hooks,
+                :shell => shell,
+                :viable => viable
+              }
+            }
+
+            let(:result) {filter.calculate_callback_name(input)}
+
+            context 'with viable hooks' do
+              let(:viable) {hooks}
+
+              it 'is a Success' do
+                expect(result).to be_a(Result::Success)
+              end
+
+              it 'has a callback name value' do
+                expect(result.value).to eql(callback_name)
+              end
+            end
+
+            context 'with no viable hooks' do
+              let(:viable) {[]}
+
+              it 'is a Failure' do
+                expect(result).to be_a(Result::Failure)
+              end
+
+              it 'includes a failure reason' do
+                expect(result.error[:reason]).to eql(:no_viable_hooks)
+              end
+
+              it 'does not modify the viable array' do
+                expect(result.error[:candidates]).to eql(hooks)
+              end
+
+              it 'does not modify the candidates array' do
+                expect(result.error[:viable]).to eql(viable)
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end
+

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