engineyard-serverside 2.8.0.pre → 3.0.3

data/spec/engineyard-serverside/callbacks/collection/service_hooks/combined_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'engineyard-serverside/callbacks/collection/service_hooks/combined'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Collection
+        module ServiceHooks
+
+          describe Combined do
+            let(:paths) {Object.new}
+            let(:app_base_path) {Pathname.new('/data/someapp')}
+            let(:shared_hooks_path) {app_base_path.join('shared', 'hooks')}
+            let(:service_1_path) {shared_hooks_path.join('svc1')}
+            let(:service_2_path) {shared_hooks_path.join('svc2')}
+            let(:service_paths) {[service_1_path.to_s, service_2_path.to_s]}
+
+            let(:service_1_hook_1) {Object.new}
+            let(:service_1_hook_2) {Object.new}
+            let(:service_2_hook_1) {Object.new}
+            let(:service_2_hook_2) {Object.new}
+
+            let(:service_1_collection) {Object.new}
+            let(:service_2_collection) {Object.new}
+
+            let(:collection) {described_class.load(paths)}
+
+            before(:each) do
+              allow(paths).
+                to receive(:shared_hooks).
+                and_return(shared_hooks_path)
+
+              allow(Dir).to receive(:[]).and_return([])
+              allow(Dir).
+                to receive(:[]).
+                with("#{shared_hooks_path}/*").
+                and_return(service_paths)
+
+              # Stub out a collection for service 1
+              allow(ServiceHooks::Collection).
+                to receive(:load).
+                with(service_1_path.to_s).
+                and_return(service_1_collection)
+
+              allow(service_1_collection).
+                to receive(:all).
+                and_return([service_1_hook_1, service_1_hook_2])
+
+              allow(service_1_collection).
+                to receive(:matching).
+                and_return([service_1_hook_2])
+
+              # Stub out a collection for service 2
+              allow(ServiceHooks::Collection).
+                to receive(:load).
+                with(service_2_path.to_s).
+                and_return(service_2_collection)
+
+              allow(service_2_collection).
+                to receive(:all).
+                and_return([service_2_hook_1, service_2_hook_2])
+
+              allow(service_2_collection).
+                to receive(:matching).
+                and_return([service_2_hook_1])
+            end
+
+            describe '.load' do
+              let(:service_hooks) {Object.new}
+              let(:result) {described_class.load(paths)}
+
+              context 'with service hooks present' do
+                it 'loads a collection for each service' do
+                  service_paths.each do |path|
+                    expect(ServiceHooks::Collection).
+                      to receive(:load).
+                      with(path)
+                  end
+
+                  result
+                end
+              end
+
+              it 'is a callbacks collection' do
+                expect(result).to be_a(Callbacks::Collection::Base)
+              end
+            end
+
+            describe '#all' do
+              let(:all_known_hooks) {
+                [
+                  service_1_hook_1,
+                  service_1_hook_2,
+                  service_2_hook_1,
+                  service_2_hook_2
+                ]
+              }
+
+              let(:result) {collection.all}
+
+              it 'is an Array' do
+                expect(result).to be_a(Array)
+              end
+
+              it 'contains all known service hooks' do
+                all_known_hooks.each do |hook|
+                  expect(result).to include(hook)
+                end
+              end
+            end
+
+            describe '#matching' do
+              let(:name) {:hook_2}
+              let(:result) {collection.matching(name)}
+
+              it 'is an Array' do
+                expect(result).to be_a(Array)
+              end
+
+              it 'contains hooks with the desired name' do
+                [service_1_hook_2, service_2_hook_1].each do |hook|
+                  expect(result).to include(hook)
+                end
+              end
+
+              it 'omits hooks without the desired name' do
+                [service_1_hook_1, service_2_hook_2].each do |hook|
+                  expect(result).not_to include(hook)
+                end
+              end
+            end
+
+            describe '#distribute' do
+              let(:runner) {Object.new}
+              let(:name) {:hook_2}
+              let(:distributor) {Callbacks::Distributor}
+              let(:distribution_result) {Object.new}
+              let(:matched) {[service_1_hook_2, service_2_hook_1]}
+              let(:result) {collection.distribute(runner, name)}
+
+              before(:each) do
+                allow(distributor).to receive(:distribute)
+
+                # Bypass Base#minimize_ruby
+                allow(collection).to receive(:minimize_ruby) {|matches|
+                  matches
+                }
+              end
+
+              it 'distributes matching hooks via an distributor' do
+                expect(distributor).
+                  to receive(:distribute).
+                  with(runner, matched).
+                  and_return(distribution_result)
+
+                expect(result).to eql(distribution_result)
+              end
+
+              it 'skips non-matching hooks' do
+                expect(distributor).not_to receive(:distribute).with(runner, :hook_1)
+
+                result
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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
+