engineyard-serverside 2.8.0.pre → 3.0.3

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

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

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+require 'result'
+require 'engineyard-serverside/slug/generator'
+
+module EY
+  module Serverside
+    module Slug
+
+      describe Generator do
+        let(:release_name) {'123456789'}
+        let(:app_name) {'george'}
+        let(:servers) {[]}
+        let(:config) {Object.new}
+        let(:shell) {Object.new}
+        let(:success) {Result::Success.new(nil)}
+        let(:failure) {Result::Failure.new(nil)}
+
+        describe '.generate' do
+          let(:data) {
+            {
+              :app_name => app_name,
+              :release_name => release_name,
+              :config => config,
+              :shell => shell,
+              :servers => servers,
+            }
+          }
+
+          let(:ogun) {
+            "/engineyard/bin/ogun build #{app_name} --release #{release_name}"
+          }
+
+          let(:generate) {described_class.generate(data)}
+
+          before(:each) do
+            allow(shell).to receive(:logged_system).and_return(failure)
+          end
+
+          it 'is a Result' do
+            expect(generate).to be_a(Result::Base)
+          end
+
+          context 'when the ogun command fails' do
+            before(:each) do
+              allow(shell).
+                to receive(:logged_system).
+                with(ogun).
+                and_return(failure)
+            end
+
+            it 'is a failure' do
+              expect(generate).to be_a(Result::Failure)
+            end
+
+            it 'records a build error' do
+              expect(generate.error[:error]).to eql('Ogun build failed')
+            end
+          end
+
+          context 'when the ogun command succeeds' do
+            before(:each) do
+              allow(shell).
+                to receive(:logged_system).
+                with(ogun).
+                and_return(success)
+            end
+
+            it 'is a success' do
+              expect(generate).to be_a(Result::Success)
+            end
+
+            it 'records that a build was generated' do
+              expect(generate.value[:generated]).to eql(true)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+require 'result'
+require 'engineyard-serverside/slug/migrator'
+
+module EY
+  module Serverside
+    module Slug
+
+      describe Migrator do
+        let(:release_name) {'123456789'}
+        let(:app_name) {'george'}
+        let(:paths) {Object.new}
+        let(:servers) {[]}
+        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(:migrator) {described_class.new(config, shell)}
+
+        describe '.migrate' do
+          let(:migrator) {Object.new}
+          let(:result) {success}
+          let(:migrate) {described_class.migrate(data)}
+
+          it 'calls a new instance' do
+            expect(described_class).
+              to receive(:new).
+              with(config, shell).
+              and_return(migrator)
+
+            expect(migrator).to receive(:call).with(data).and_return(result)
+
+            expect(migrate).to eql(success)
+          end
+        end
+
+        describe '#call' do
+          let(:binstubs) {"/path/to/binstubs"}
+          let(:active_release) {"/path/to/active_release"}
+          let(:framework_envs) {
+            "RAILS_ENV=whatever MERB_ENV=whatever NODEJS_ENV=whatever"
+          }
+          let(:migration_command) {'rake db:migrate'}
+          let(:cmd) {
+            "PATH=#{binstubs}:$PATH #{framework_envs} #{migration_command}"
+          }
+
+          let(:result) {migrator.call(data)}
+
+          before(:each) do
+            allow(config).to receive(:paths).and_return(paths)
+            allow(config).to receive(:framework_envs).and_return(framework_envs)
+            allow(config).to receive(:migrate?).and_return(false)
+            allow(config).
+              to receive(:migration_command).
+              and_return(migration_command)
+
+            allow(paths).to receive(:binstubs).and_return(binstubs)
+            allow(paths).to receive(:active_release).and_return(active_release)
+
+            allow(Dir).to receive(:chdir).and_yield
+            allow(migrator).to receive(:run_and_success?).and_return(false)
+          end
+
+          context 'when migrations are not requested' do
+            before(:each) do
+              allow(config).to receive(:migrate?).and_return(false)
+            end
+
+            it 'is a success' do
+              expect(result).to be_a(Result::Success)
+            end
+
+            it 'does not modify its input' do
+              expect(result.value).to eql(data)
+            end
+          end
+
+          context 'when migrations are requested' do
+            before(:each) do
+              allow(config).to receive(:migrate?).and_return(true)
+              expect(Dir).to receive(:chdir).with(active_release).and_yield
+            end
+
+            context 'but the migration command fails' do
+              before(:each) do
+                allow(migrator).
+                  to receive(:run_and_success?).
+                  with(cmd).
+                  and_return(false)
+              end
+
+              it 'is a failure' do
+                expect(result).to be_a(Result::Failure)
+              end
+
+              it 'contains an error regarding the failed migration' do
+                expect(result.error[:error]).
+                  to eql("Could not migrate database")
+              end
+            end
+
+            context 'and the migration command succeeds' do
+              before(:each) do
+                allow(migrator).
+                  to receive(:run_and_success?).
+                  with(cmd).
+                  and_return(true)
+              end
+
+              it 'is a success' do
+                expect(result).to be_a(Result::Success)
+              end
+
+              it 'records the successful migration' do
+                expect(result.value[:migrated]).to eql(true)
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,226 @@
+require 'ostruct'
+
+require 'spec_helper'
+
+require 'result'
+require 'engineyard-serverside/slug/restarter'
+
+module EY
+  module Serverside
+    module Slug
+
+      describe Restarter 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(:app1) {
+          OpenStruct.new(
+            :hostname => 'server2',
+            :role => :app,
+            :user => 'deployapp'
+          )
+        }
+
+        let(:app2) {
+          OpenStruct.new(
+            :hostname => 'server3',
+            :role => :app,
+            :user => 'deployapp'
+          )
+        }
+
+
+        let(:util) {
+          OpenStruct.new(
+            :hostname => 'server4',
+            :role => :util,
+            :user => 'deployutil'
+          )
+        }
+
+        let(:servers) {[app_master, app1, app2, 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(:restarter) {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(restarter).to be_a(Railway)
+        end
+
+        it 'is a Runner' do
+          expect(restarter).to be_a(Runner)
+        end
+
+        it 'has the exact steps for restartingting a packaged app' do
+          steps = described_class.steps.map {|s| s[:name]}
+
+          expect(steps).to eql(
+            [
+              :restart_remote_apps,
+              :restart_local
+            ]
+          )
+        end
+
+        describe '.restart' do
+          let(:restarter) {Object.new}
+
+          it 'restarts via a new instance' do
+            expect(described_class).
+              to receive(:new).
+              with(config, shell, servers).
+              and_return(restarter)
+
+            expect(restarter).to receive(:call).with(data).and_return(success)
+
+            described_class.restart(data)
+          end
+        end
+
+        describe '#restart_remote_apps' do
+          let(:remote_apps) {[app1, app2]}
+          let(:result) {restarter.send(:restart_remote_apps, data)}
+
+          before(:each) do
+            remote_apps.each do |remote|
+              allow(restarter).
+                to receive(:run_and_success?).
+                with(restarter.send(:remote_command, remote, data)).
+                and_return(true)
+            end
+          end
+
+          it 'executes the enable command for each app remote' do
+            remote_apps.each do |remote|
+              expect(restarter).
+                to receive(:run_and_success?).
+                with(restarter.send(:remote_command, remote, data)).
+                and_return(true)
+            end
+
+            result
+          end
+
+          it 'omits utility instances from restart' do
+            expect(restarter).
+              not_to receive(:run_and_success?).
+              with(restarter.send(:remote_command, util, data))
+
+            result
+          end
+
+          context 'when any execution fails' do
+            before(:each) do
+              allow(restarter).
+                to receive(:run_and_success?).
+                with(restarter.send(:remote_command, app2, data)).
+                and_return(false)
+            end
+
+            it 'is a failure' do
+              expect(result).to be_a(Result::Failure)
+            end
+
+            it 'records the restart error' do
+              expect(result.error[:error]).
+                to eql("Could not restart #{release_name} on #{app2.hostname}")
+            end
+
+            it 'records any servers that were successfully restarted' do
+              expect(result.error[:restarted]).to include(app1)
+            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 restarted servers' do
+              expect(result.value[:restarted]).to include(app1)
+              expect(result.value[:restarted]).to include(app2)
+            end
+          end
+        end
+
+        describe '#restart_local' do
+          let(:local_data) {data.merge(:restarted => [app1, app2])}
+          let(:result) {restarter.send(:restart_local, local_data)}
+
+          it 'runs the local restart command' do
+            expect(restarter).
+              to receive(:run_and_success?).
+              with(restarter.send(:restart_command, local_data))
+
+            result
+          end
+
+          context 'when execution fails' do
+            before(:each) do
+              allow(restarter).
+                to receive(:run_and_success?).
+                with(restarter.send(:restart_command, local_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 restart #{release_name} on the app master")
+            end
+          end
+
+          context 'when execution succeeds' do
+            before(:each) do
+              allow(restarter).
+                to receive(:run_and_success?).
+                with(restarter.send(:restart_command, local_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[:restarted]).to include(app_master)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end