engineyard-serverside 2.8.0.pre4 → 3.0.4

data/spec/engineyard-serverside/slug/distributor_spec.rb

@@ -0,0 +1,199 @@
+require 'ostruct'
+
+require 'spec_helper'
+
+require 'result'
+require 'engineyard-serverside/slug/distributor'
+
+module EY
+  module Serverside
+    module Slug
+
+      describe Distributor do
+        let(:release_name) {'123456789'}
+        let(:app_name) {'george'}
+        let(:internal_key) {'/path/to/internal/key'}
+        let(:paths) {Object.new}
+
+        let(:app_master) {
+          OpenStruct.new(
+            :hostname => 'server1',
+            :role => :app_master,
+            :user => 'deploy'
+          )
+        }
+
+        let(:app) {
+          OpenStruct.new(
+            :hostname => 'server2',
+            :role => :app,
+            :user => 'deployapp'
+          )
+        }
+
+        let(:util) {
+          OpenStruct.new(
+            :hostname => 'server1',
+            :role => :util,
+            :user => 'deployutil'
+          )
+        }
+
+        let(:servers) {[app_master, app, util]}
+
+        let(:config) {Object.new}
+        let(:shell) {Object.new}
+        let(:success) {Result::Success.new(nil)}
+        let(:failure) {Result::Failure.new(nil)}
+
+        let(:data) {
+          {
+            :app_name => app_name,
+            :release_name => release_name,
+            :config => config,
+            :shell => shell,
+            :servers => servers
+          }
+        }
+
+        let(:distributor) {described_class.new(config, shell, servers)}
+
+        before(:each) do
+          allow(config).to receive(:paths).and_return(paths)
+
+          allow(paths).to receive(:internal_key).and_return(internal_key)
+        end
+
+        it 'is a Railway' do
+          expect(distributor).to be_a(Railway)
+        end
+
+        it 'has the exact steps for distributing a packaged app' do
+          steps = described_class.steps.map {|s| s[:name]}
+
+          expect(steps).to eql(
+            [
+              :find_remotes,
+              :distribute_to_remotes
+            ]
+          )
+        end
+
+        describe '.distribute' do
+          let(:distributor) {Object.new}
+          let(:result) {success}
+          let(:distribute) {described_class.distribute(data)}
+
+          it 'calls a new instance' do
+            expect(described_class).
+              to receive(:new).
+              with(config, shell, servers).
+              and_return(distributor)
+
+            expect(distributor).to receive(:call).with(data).and_return(result)
+
+            expect(distribute).to eql(success)
+          end
+        end
+
+        describe '#find_remotes' do
+          let(:find_remotes) {distributor.send(:find_remotes, data)}
+
+          it 'is a success' do
+            expect(find_remotes).to be_a(Result::Success)
+          end
+
+          it 'records the remotes in its output' do
+            remotes = find_remotes.value[:remotes]
+            expect(remotes).to include(app)
+            expect(remotes).to include(util)
+          end
+
+          it 'omits app master from the remotes' do
+            expect(find_remotes.value[:remotes]).not_to include(app_master)
+          end
+        end
+
+        describe '#distribute_to_remotes' do
+          let(:releases_path) {"/data/#{app_name}/releases"}
+          let(:package) {"#{releases_path}/#{release_name}.tgz"}
+          let(:remotes) {[app, util]}
+          let(:distribute_input) {data.merge(:remotes => remotes)}
+
+          let(:distribute) {
+            distributor.send(:distribute_to_remotes, distribute_input)
+          }
+
+          before(:each) do
+            remotes.each do |server|
+              allow(distributor).
+                to receive(:run_and_success?).
+                with(
+                  "scp -i #{internal_key} #{package} #{server.user}@#{server.hostname}:#{releases_path}"
+                ).
+                and_return(true)
+            end
+          end
+
+          it 'copies the package to each remote' do
+            remotes.each do |server|
+              expect(distributor).
+                to receive(:run_and_success?).
+                with(
+                  "scp -i #{internal_key} #{package} #{server.user}@#{server.hostname}:#{releases_path}"
+                )
+            end
+
+            distribute
+          end
+
+          context 'when any copy process fails' do
+            before(:each) do
+              allow(distributor).
+                to receive(:run_and_success?).
+                with("scp -i #{internal_key} #{package} #{app.user}@#{app.hostname}:#{releases_path}").
+                and_return(false)
+
+              allow(distributor).
+                to receive(:run_and_success?).
+                with("scp -i #{internal_key} #{package} #{util.user}@#{util.hostname}:#{releases_path}").
+                and_return(false)
+            end
+
+            it 'is a failure' do
+              expect(distribute).to be_a(Result::Failure)
+            end
+
+            it 'records an error regarding the failed copies' do
+              expect(distribute.error[:error]).to eql("Could not copy #{package} to #{app.hostname}")
+            end
+          end
+
+          context 'when all copy processes succeed' do
+            before(:each) do
+              remotes.each do |server|
+                allow(distributor).
+                  to receive(:run_and_success?).
+                  with(
+                    "scp -i #{internal_key} #{package} #{server.user}@#{server.hostname}:#{releases_path}"
+                  ).
+                  and_return(true)
+              end
+            end
+
+            it 'is a success' do
+              expect(distribute).to be_a(Result::Success)
+            end
+
+            it 'does not modify its input' do
+              expect(distribute.value).to eql(distribute_input)
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end
+

data/spec/engineyard-serverside/slug/enabler_spec.rb

@@ -0,0 +1,191 @@
+require 'ostruct'
+
+require 'spec_helper'
+
+require 'result'
+require 'engineyard-serverside/slug/enabler'
+
+module EY
+  module Serverside
+    module Slug
+
+      describe Enabler do
+        let(:release_name) {'123456789'}
+        let(:app_name) {'george'}
+        let(:internal_key) {'/path/to/internal/key'}
+        let(:paths) {Object.new}
+
+        let(:app_master) {
+          OpenStruct.new(
+            :hostname => 'server1',
+            :role => :app_master,
+            :user => 'deploy'
+          )
+        }
+
+        let(:app) {
+          OpenStruct.new(
+            :hostname => 'server2',
+            :role => :app,
+            :user => 'deployapp'
+          )
+        }
+
+        let(:util) {
+          OpenStruct.new(
+            :hostname => 'server1',
+            :role => :util,
+            :user => 'deployutil'
+          )
+        }
+
+        let(:servers) {[app_master, app, util]}
+
+        let(:config) {Object.new}
+        let(:shell) {Object.new}
+        let(:success) {Result::Success.new(nil)}
+        let(:failure) {Result::Failure.new(nil)}
+
+        let(:data) {
+          {
+            :app_name => app_name,
+            :release_name => release_name,
+            :config => config,
+            :shell => shell,
+            :servers => servers
+          }
+        }
+
+        let(:enabler) {described_class.new(config, shell, servers)}
+
+        before(:each) do
+          allow(config).to receive(:paths).and_return(paths)
+
+          allow(paths).to receive(:internal_key).and_return(internal_key)
+        end
+
+        it 'is a Railway' do
+          expect(enabler).to be_a(Railway)
+        end
+
+        it 'has the exact steps for distributing a packaged app' do
+          steps = described_class.steps.map {|s| s[:name]}
+
+          expect(steps).to eql(
+            [
+              :enable_remotes,
+              :enable_local
+            ]
+          )
+        end
+
+        describe '#enable_remotes' do
+          let(:remotes) {[app, util]}
+          let(:result) {enabler.send(:enable_remotes, data)}
+
+          before(:each) do
+            remotes.each do |remote|
+              allow(enabler).
+                to receive(:run_and_success?).
+                with(enabler.send(:remote_command, remote, data)).
+                and_return(true)
+            end
+          end
+
+          it 'executes the enable command for each remote' do
+            remotes.each do |remote|
+              expect(enabler).
+                to receive(:run_and_success?).
+                with(enabler.send(:remote_command, remote, data)).
+                and_return(true)
+            end
+
+            result
+          end
+
+          context 'when any execution fails' do
+            before(:each) do
+              expect(enabler).
+                to receive(:run_and_success?).
+                with(enabler.send(:remote_command, app, data)).
+                and_return(false)
+
+              expect(enabler).
+                not_to receive(:run_and_success?).
+                with(enabler.send(:remote_command, util, data))
+            end
+
+            it 'is a failure' do
+              expect(result).to be_a(Result::Failure)
+            end
+
+            it 'records the enabling error' do
+              expect(result.error[:error]).
+                to eql("Could not enable #{release_name} on #{app.hostname}")
+            end
+          end
+
+          context 'when all executions succeed' do
+            it 'is a success' do
+              expect(result).to be_a(Result::Success)
+            end
+
+            it 'records the successfully enabled servers' do
+              expect(result.value[:enabled]).to include(app)
+              expect(result.value[:enabled]).to include(util)
+            end
+          end
+        end
+
+        describe '#enable_local' do
+          let(:local_data) {data.merge(:enabled => [app, util])}
+          let(:result) {enabler.send(:enable_local, local_data)}
+
+          it 'runs the local enable command' do
+            expect(enabler).
+              to receive(:run_and_success?).
+              with(enabler.send(:local_command, data))
+
+            result
+          end
+
+          context 'when execution fails' do
+            before(:each) do
+              allow(enabler).
+                to receive(:run_and_success?).
+                with(enabler.send(:local_command, data)).
+                and_return(false)
+            end
+
+            it 'is a failure' do
+              expect(result).to be_a(Result::Failure)
+            end
+
+            it 'records the error' do
+              expect(result.error[:error]).to eql("Could not enable #{release_name} on the app master")
+            end
+          end
+
+          context 'when execution succeeds' do
+            before(:each) do
+              allow(enabler).
+                to receive(:run_and_success?).
+                with(enabler.send(:local_command, data)).
+                and_return(true)
+            end
+
+            it 'is a success' do
+              expect(result).to be_a(Result::Success)
+            end
+
+            it 'adds the app master to the enabled list' do
+              expect(result.value[:enabled]).to include(app_master)
+            end
+          end
+        end
+
+
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/slug/failure_handler_spec.rb

@@ -0,0 +1,114 @@
+require 'ostruct'
+
+require 'spec_helper'
+
+require 'result'
+require 'engineyard-serverside/slug/failure_handler'
+
+module EY
+  module Serverside
+    module Slug
+
+      describe FailureHandler do
+        let(:release_name) {'123456789'}
+        let(:app_name) {'george'}
+        let(:internal_key) {'/path/to/internal/key'}
+        let(:paths) {Object.new}
+
+        let(:app_master) {
+          OpenStruct.new(
+            :hostname => 'server1',
+            :role => :app_master,
+            :user => 'deploy'
+          )
+        }
+
+        let(:app) {
+          OpenStruct.new(
+            :hostname => 'server2',
+            :role => :app,
+            :user => 'deployapp'
+          )
+        }
+
+        let(:util) {
+          OpenStruct.new(
+            :hostname => 'server1',
+            :role => :util,
+            :user => 'deployutil'
+          )
+        }
+
+        let(:servers) {[app_master, app, util]}
+
+        let(:config) {Object.new}
+        let(:shell) {Object.new}
+        let(:success) {Result::Success.new(nil)}
+        let(:failure) {Result::Failure.new(nil)}
+
+        let(:data) {
+          {
+            :app_name => app_name,
+            :release_name => release_name,
+            :config => config,
+            :shell => shell,
+            :servers => servers
+          }
+        }
+
+        let(:handler) {described_class.new(config, shell, servers)}
+
+        before(:each) do
+          allow(config).to receive(:paths).and_return(paths)
+
+          allow(paths).to receive(:internal_key).and_return(internal_key)
+        end
+
+        #it 'is a Railway' do
+          #expect(handler).to be_a(Railway)
+        #end
+
+        #it 'has the exact steps for distributing a packaged app' do
+          #steps = described_class.steps.map {|s| s[:name]}
+
+          #expect(steps).to eql(
+            #[
+              #:handle_finalization_failure,
+              #:handle_restart_failure,
+              #:handle_enable_failure,
+              #:handle_distribute_failure,
+            #]
+          #)
+        #end
+
+        describe '.handle' do
+          let(:handler) {Object.new}
+
+          it 'calls a new handler' do
+            expect(described_class).
+              to receive(:new).
+              with(config, shell, servers).
+              and_return(handler)
+
+            expect(handler).to receive(:call).with(data).and_return(success)
+
+            expect(described_class.handle(data)).to eql(success)
+          end
+        end
+
+        describe '#call' do
+          let(:result) {handler.call(data)}
+
+          it 'is a failure' do
+            expect(result).to be_a(Result::Failure)
+          end
+
+          it 'does not modify its input' do
+            expect(result.error).to eql(data)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/engineyard-serverside/slug/finalizer_spec.rb

@@ -0,0 +1,191 @@
+require 'ostruct'
+
+require 'spec_helper'
+
+require 'result'
+require 'engineyard-serverside/slug/finalizer'
+
+module EY
+  module Serverside
+    module Slug
+
+      describe Finalizer do
+        let(:release_name) {'123456789'}
+        let(:app_name) {'george'}
+        let(:internal_key) {'/path/to/internal/key'}
+        let(:paths) {Object.new}
+
+        let(:app_master) {
+          OpenStruct.new(
+            :hostname => 'server1',
+            :role => :app_master,
+            :user => 'deploy'
+          )
+        }
+
+        let(:app) {
+          OpenStruct.new(
+            :hostname => 'server2',
+            :role => :app,
+            :user => 'deployapp'
+          )
+        }
+
+        let(:util) {
+          OpenStruct.new(
+            :hostname => 'server1',
+            :role => :util,
+            :user => 'deployutil'
+          )
+        }
+
+        let(:servers) {[app_master, app, util]}
+
+        let(:config) {Object.new}
+        let(:shell) {Object.new}
+        let(:success) {Result::Success.new(nil)}
+        let(:failure) {Result::Failure.new(nil)}
+
+        let(:data) {
+          {
+            :app_name => app_name,
+            :release_name => release_name,
+            :config => config,
+            :shell => shell,
+            :servers => servers
+          }
+        }
+
+        let(:finalizer) {described_class.new(config, shell, servers)}
+
+        before(:each) do
+          allow(config).to receive(:paths).and_return(paths)
+
+          allow(paths).to receive(:internal_key).and_return(internal_key)
+        end
+
+        it 'is a Railway' do
+          expect(finalizer).to be_a(Railway)
+        end
+
+        it 'has the exact steps for distributing a packaged app' do
+          steps = described_class.steps.map {|s| s[:name]}
+
+          expect(steps).to eql(
+            [
+              :finalize_remotes,
+              :finalize_local
+            ]
+          )
+        end
+
+        describe '#finalize_remotes' do
+          let(:remotes) {[app, util]}
+          let(:result) {finalizer.send(:finalize_remotes, data)}
+
+          before(:each) do
+            remotes.each do |remote|
+              allow(finalizer).
+                to receive(:run_and_success?).
+                with(finalizer.send(:remote_command, remote, data)).
+                and_return(true)
+            end
+          end
+
+          it 'executes the enable command for each remote' do
+            remotes.each do |remote|
+              expect(finalizer).
+                to receive(:run_and_success?).
+                with(finalizer.send(:remote_command, remote, data)).
+                and_return(true)
+            end
+
+            result
+          end
+
+          context 'when any execution fails' do
+            before(:each) do
+              expect(finalizer).
+                to receive(:run_and_success?).
+                with(finalizer.send(:remote_command, app, data)).
+                and_return(false)
+
+              expect(finalizer).
+                not_to receive(:run_and_success?).
+                with(finalizer.send(:remote_command, util, data))
+            end
+
+            it 'is a failure' do
+              expect(result).to be_a(Result::Failure)
+            end
+
+            it 'records the enabling error' do
+              expect(result.error[:error]).
+                to eql("Could not finalize #{release_name} on #{app.hostname}")
+            end
+          end
+
+          context 'when all executions succeed' do
+            it 'is a success' do
+              expect(result).to be_a(Result::Success)
+            end
+
+            it 'records the successfully enabled servers' do
+              expect(result.value[:finalized]).to include(app)
+              expect(result.value[:finalized]).to include(util)
+            end
+          end
+        end
+
+        describe '#finalize_local' do
+          let(:local_data) {data.merge(:finalized => [app, util])}
+          let(:result) {finalizer.send(:finalize_local, local_data)}
+
+          it 'runs the local enable command' do
+            expect(finalizer).
+              to receive(:run_and_success?).
+              with(finalizer.send(:finalize_command, data))
+
+            result
+          end
+
+          context 'when execution fails' do
+            before(:each) do
+              allow(finalizer).
+                to receive(:run_and_success?).
+                with(finalizer.send(:finalize_command, data)).
+                and_return(false)
+            end
+
+            it 'is a failure' do
+              expect(result).to be_a(Result::Failure)
+            end
+
+            it 'records the error' do
+              expect(result.error[:error]).to eql("Could not finalize #{release_name} on the app master")
+            end
+          end
+
+          context 'when execution succeeds' do
+            before(:each) do
+              allow(finalizer).
+                to receive(:run_and_success?).
+                with(finalizer.send(:finalize_command, data)).
+                and_return(true)
+            end
+
+            it 'is a success' do
+              expect(result).to be_a(Result::Success)
+            end
+
+            it 'adds the app master to the enabled list' do
+              expect(result.value[:finalized]).to include(app_master)
+            end
+          end
+        end
+
+
+      end
+    end
+  end
+end