engineyard-serverside 2.8.0.pre → 3.0.3

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '2.8.0.pre'
+    VERSION = '3.0.3'
   end
 end

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

@@ -0,0 +1,232 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'engineyard-serverside/callbacks/collection/combined'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Collection
+
+        describe Combined do
+          let(:paths) {Object.new}
+          let(:deploy_hook_1) {Object.new}
+          let(:deploy_hook_2) {Object.new}
+          let(:service_hook_1) {Object.new}
+          let(:service_hook_2) {Object.new}
+          let(:deploy_hooks) {Object.new}
+          let(:service_hooks) {Object.new}
+
+          let(:collection) {described_class.load(paths)}
+
+          before(:each) do
+            # Stub out the DeployHooks collection upon which we depend
+            allow(DeployHooks).
+              to receive(:load).
+              with(paths).
+              and_return(deploy_hooks)
+
+            allow(deploy_hooks).
+              to receive(:all).
+              and_return([deploy_hook_1, deploy_hook_2])
+
+            allow(deploy_hooks).
+              to receive(:matching).
+              and_return([deploy_hook_1])
+
+            # Stub out the ServiceHooks collection upon which we depend
+            allow(ServiceHooks).
+              to receive(:load).
+              with(paths).
+              and_return(service_hooks)
+
+            allow(service_hooks).
+              to receive(:all).
+              and_return([service_hook_1, service_hook_2])
+
+            allow(service_hooks).
+              to receive(:matching).
+              and_return([service_hook_2])
+
+            # Make all of our "hooks" of the executable flavor by default
+            [
+              deploy_hook_1, deploy_hook_2, service_hook_1, service_hook_2
+            ].each do |hook|
+              allow(hook).to receive(:flavor).and_return(:executable)
+            end
+
+          end
+
+          describe '.load' do
+            let(:deploy_hooks) {Object.new}
+            let(:service_hooks) {Object.new}
+            let(:result) {described_class.load(paths)}
+
+
+            it 'loads deploy hooks' do
+              expect(DeployHooks).to receive(:load).with(paths)
+
+              result
+            end
+
+            it 'loads service hooks' do
+              expect(ServiceHooks).to receive(:load).with(paths)
+
+              result
+            end
+
+            it 'is a callbacks collection' do
+              expect(result).to be_a(Collection::Base)
+            end
+          end
+
+          describe '#all' do
+            let(:result) {collection.all}
+
+            it 'is an Array' do
+              expect(result).to be_a(Array)
+            end
+
+            it 'contains the deploy hooks' do
+              [deploy_hook_1, deploy_hook_2].each do |hook|
+                expect(result).to include(hook)
+              end
+            end
+
+            it 'contains the service hooks' do
+              [service_hook_1, service_hook_2].each do |hook|
+                expect(result).to include(hook)
+              end
+            end
+
+            it 'gives more priority to service hooks' do
+              expect(result).to eql(
+                [service_hook_1, service_hook_2, deploy_hook_1, deploy_hook_2]
+              )
+            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_hook_2, deploy_hook_1].each do |hook|
+                expect(result).to include(hook)
+              end
+            end
+
+            it 'omits hooks without the desired name' do
+              [service_hook_1, deploy_hook_2].each do |hook|
+                expect(result).not_to include(hook)
+              end
+            end
+          end
+
+          describe '#execute' do
+            let(:config) {Object.new}
+            let(:shell) {Object.new}
+            let(:callback) {Object.new}
+            let(:matches) {[]}
+
+            let(:result) {collection.execute(config, shell, callback)}
+
+            before(:each) do
+              allow(Executor).to receive(:execute)
+              allow(shell).to receive(:info)
+              allow(collection).
+                to receive(:matching).
+                with(callback).
+                and_return(matches)
+            end
+
+            context 'when there are matching hooks' do
+              let(:matches) {[Object.new]}
+
+              it 'executes those matching hooks' do
+                expect(Executor).to receive(:execute).with(config, shell, matches)
+
+                result
+              end
+            end
+
+            context 'when there are not matching hooks' do
+              let(:matches) {[]}
+
+              it 'logs a message about the lack of matching hooks' do
+                expect(shell).
+                  to receive(:info).
+                  with("No hooks detected for #{callback}. Skipping.")
+
+                result
+              end
+
+              it 'does not execute any hooks' do
+                expect(Executor).not_to receive(:execute)
+
+                result
+              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_hook_2, deploy_hook_1]}
+            let(:result) {collection.distribute(runner, name)}
+
+            before(:each) do
+              allow(distributor).to receive(:distribute)
+            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
+
+            context 'when there are multiple matching ruby hooks' do
+              before(:each) do
+                allow(service_hook_2).to receive(:flavor).and_return(:ruby)
+                allow(deploy_hook_1).to receive(:flavor).and_return(:ruby)
+              end
+
+              it 'distributes the first ruby hook' do
+                expect(distributor).
+                  to receive(:distribute).
+                  with(runner, [service_hook_2])
+
+                result
+              end
+
+              it 'does not distribute any other ruby hook' do
+                expect(distributor).
+                  not_to receive(:distribute).
+                  with(runner, [service_hook_2, deploy_hook_1])
+
+                result
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'engineyard-serverside/callbacks/collection'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Collection
+
+        describe DeployHooks do
+          
+          let(:paths) {Object.new}
+          let(:app_base_path) {Pathname.new('/data/some_app')}
+          let(:deploy_hooks_path) {
+            app_base_path.join('releases', 'TIMESTAMP', 'deploy')
+          }
+
+          let(:hook_1_path) {deploy_hooks_path.join('hook_1.rb')}
+          let(:hook_2_path) {deploy_hooks_path.join('hook_2.rb')}
+          let(:hook_paths) {[hook_1_path.to_s, hook_2_path.to_s]}
+
+          let(:collection) {described_class.load(paths)}
+
+          before(:each) do
+            allow(paths).to receive(:deploy_hooks).and_return(deploy_hooks_path)
+            allow(Dir).to receive(:[]).and_return([])
+          end
+
+          describe '.load' do
+            let(:result) {described_class.load(paths)}
+
+            context 'with application hooks present' do
+              before(:each) do
+                allow(Dir).
+                  to receive(:[]).
+                  with("#{deploy_hooks_path}/*").
+                  and_return(hook_paths)
+              end
+
+              it 'loads those application hooks' do
+                expect(Hooks::App).to receive(:new).with(hook_1_path.to_s)
+                expect(Hooks::App).to receive(:new).with(hook_2_path.to_s)
+
+                result
+              end
+            end
+
+            it 'is a callbacks collection' do
+              expect(result).to be_a(Collection::Base)
+            end
+          end
+
+          describe '#all' do
+            let(:result) {collection.all}
+
+            before(:each) do
+              allow(Dir).
+                to receive(:[]).
+                with("#{deploy_hooks_path}/*").
+                and_return(hook_paths)
+            end
+
+            it 'is an Array' do
+              expect(result).to be_a(Array)
+            end
+
+            it 'contains all of the hooks detected at load time' do
+              hook_paths.each do |path|
+                expect(
+                  result.select {|h| h.path == Pathname(path)}.length
+                ).to eql(1)
+              end
+            end
+          end
+
+          describe '#matching' do
+            let(:name) {:hook_2}
+            let(:result) {collection.matching(name)}
+
+            before(:each) do
+              allow(Dir).
+                to receive(:[]).
+                with("#{deploy_hooks_path}/*").
+                and_return(hook_paths)
+            end
+
+            it 'is an Array' do
+              expect(result).to be_a(Array)
+            end
+
+            it 'contains hooks with the desired name' do
+              expect(
+                result.select {|h| h.path == Pathname(hook_2_path)}.length
+              ).to eql(1)
+            end
+
+            it 'omits hooks without the desired name' do
+              expect(
+                result.select {|h| h.path == Pathname(hook_1_path)}.length
+              ).to eql(0)
+            end
+
+            context "when a hook is represented by more than one format" do
+              let(:hook_1_path) {deploy_hooks_path.join('hook_2')}
+              let(:hook_2_path) {deploy_hooks_path.join('hook_2.rb')}
+
+              it 'contains the ruby hook' do
+                expect(
+                  result.select {|h| h.path == Pathname(hook_2_path)}.length
+                ).to eql(1)
+              end
+
+              it 'omits the other hooks' do
+                expect(
+                  result.select {|h| h.path == Pathname(hook_1_path)}.length
+                ).to eql(0)
+              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) {Object.new}
+            let(:result) {collection.distribute(runner, name)}
+
+            before(:each) do
+              allow(Dir).
+                to receive(:[]).
+                with("#{deploy_hooks_path}/*").
+                and_return(hook_paths)
+
+              allow(collection).
+                to receive(:matching).
+                with(name).
+                and_return(matched)
+
+              # Bypass Base#minimize_ruby
+              allow(collection).to receive(:minimize_ruby) {|matches|
+                matches
+              }
+
+              allow(distributor).to receive(:distribute)
+            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

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

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+require 'pathname'
+
+require 'engineyard-serverside/callbacks/collection/service_hooks/collection'
+
+module EY
+  module Serverside
+    module Callbacks
+      module Collection
+        module ServiceHooks
+
+          describe Collection do
+            let(:app_base_path) {Pathname.new('/data/some_app')}
+            let(:shared_hooks_path) {
+              app_base_path.join('shared', 'hooks')
+            }
+
+            let(:service_1_path) {shared_hooks_path.join('svc1')}
+
+            let(:hook_1_path) {service_1_path.join('hook_1.rb')}
+            let(:hook_2_path) {service_1_path.join('hook_2.rb')}
+            let(:hook_paths) {[hook_1_path.to_s, hook_2_path.to_s]}
+
+            let(:collection) {described_class.load(service_1_path)}
+
+            before(:each) do
+              allow(Dir).to receive(:[]).and_return([])
+            end
+
+            describe '.load' do
+              let(:result) {described_class.load(service_1_path)}
+
+              context 'with service hooks present' do
+                before(:each) do
+                  allow(Dir).
+                    to receive(:[]).
+                    with("#{service_1_path}/*").
+                    and_return(hook_paths)
+                end
+
+                it 'loads those service hooks' do
+                  expect(Hooks::Service).to receive(:new).with(hook_1_path.to_s)
+                  expect(Hooks::Service).to receive(:new).with(hook_2_path.to_s)
+
+                  result
+                end
+              end
+
+              it 'is a callbacks collection' do
+                expect(result).to be_a(Callbacks::Collection::Base)
+              end
+            end
+
+            describe '#all' do
+              let(:result) {collection.all}
+
+              before(:each) do
+                allow(Dir).
+                  to receive(:[]).
+                  with("#{service_1_path}/*").
+                  and_return(hook_paths)
+              end
+
+              it 'is an Array' do
+                expect(result).to be_a(Array)
+              end
+
+              it 'contains all of the hooks detected at load time' do
+                hook_paths.each do |path|
+                  expect(
+                    result.select {|h| h.path == Pathname(path)}.length
+                  ).to eql(1)
+                end
+              end
+            end
+
+            describe '#matching' do
+              let(:name) {:hook_2}
+              let(:result) {collection.matching(name)}
+
+              before(:each) do
+                allow(Dir).
+                  to receive(:[]).
+                  with("#{service_1_path}/*").
+                  and_return(hook_paths)
+              end
+
+              it 'is an Array' do
+                expect(result).to be_a(Array)
+              end
+
+              it 'contains hooks with the desired name' do
+                expect(
+                  result.select {|h| h.path == Pathname(hook_2_path)}.length
+                ).to eql(1)
+              end
+
+              it 'omits hooks without the desired name' do
+                expect(
+                  result.select {|h| h.path == Pathname(hook_1_path)}.length
+                ).to eql(0)
+              end
+
+              context "when a hook is represented by more than one format" do
+                let(:hook_1_path) {service_1_path.join('hook_2')}
+                let(:hook_2_path) {service_1_path.join('hook_2.rb')}
+
+                it 'contains the ruby hook' do
+                  expect(
+                    result.select {|h| h.path == Pathname(hook_2_path)}.length
+                  ).to eql(1)
+                end
+
+                it 'omits the other hooks' do
+                  expect(
+                    result.select {|h| h.path == Pathname(hook_1_path)}.length
+                  ).to eql(0)
+                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) {Object.new}
+              let(:result) {collection.distribute(runner, name)}
+
+              before(:each) do
+                allow(Dir).
+                  to receive(:[]).
+                  with("#{service_1_path}/*").
+                  and_return(hook_paths)
+
+                allow(collection).
+                  to receive(:matching).
+                  with(name).
+                  and_return(matched)
+
+                # Bypass Base#minimize_ruby
+                allow(collection).to receive(:minimize_ruby) {|matches|
+                  matches
+                }
+
+                allow(distributor).to receive(:distribute)
+              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