engineyard-serverside 2.8.0.pre4 → 3.0.4

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

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
+