engineyard-serverside 2.8.0.pre4 → 3.0.4

data/spec/engineyard-serverside/cli/workflows/calling_deploy_hooks_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/cli/workflows/calling_deploy_hooks'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+        describe CallingDeployHooks do
+          let(:config) {Object.new}
+          let(:shell) {Object.new}
+          let(:paths) {Object.new}
+          let(:callbacks) {Object.new}
+          let(:hook_name) {'joe'}
+          let(:options) {{:hook_name => hook_name}}
+          let(:workflow) {described_class.new(options)}
+
+          before(:each) do
+            allow(shell).to receive(:fatal)
+            allow(shell).to receive(:debug)
+
+            allow(config).to receive(:verbose)
+            allow(config).to receive(:app)
+            allow(config).to receive(:paths).and_return(paths)
+
+            allow(workflow).to receive(:shell).and_return(shell)
+            allow(workflow).to receive(:config).and_return(config)
+
+            allow(Callbacks).to receive(:load).and_return(callbacks)
+            allow(callbacks).to receive(:execute)
+            allow(callbacks).to receive(:empty?).and_return(false)
+          end
+
+          it 'is a CLI Workflow' do
+            expect(workflow).to be_a(EY::Serverside::CLI::Workflows::Base)
+          end
+
+          it 'has a task name' do
+            expect(workflow.instance_eval {task_name}).
+              to eql("hook-#{hook_name}")
+          end
+
+          describe '#perform' do
+            let(:deploy_hook) {Object.new}
+
+            let(:perform) {workflow.perform}
+
+            it 'does not propagates serverside' do
+              expect(workflow).not_to receive(:propagate_serverside)
+
+              perform
+            end
+
+            it 'calls the requested deploy hook via the Callbacks system' do
+              expect(Callbacks).to receive(:load).with(paths).and_return(callbacks)
+              expect(callbacks).to receive(:execute).with(config, shell, hook_name)
+
+              perform
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/cli/workflows/deploying_applications_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/cli/workflows/deploying_applications'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+        describe DeployingApplications do
+          let(:config) {Object.new}
+          let(:shell) {Object.new}
+          let(:options) {{}}
+          let(:deployer) {Object.new}
+          let(:workflow) {described_class.new(options)}
+
+          before(:each) do
+            allow(shell).to receive(:fatal)
+            allow(shell).to receive(:debug)
+
+            allow(config).to receive(:verbose)
+            allow(config).to receive(:app)
+
+            allow(workflow).to receive(:shell).and_return(shell)
+            allow(workflow).to receive(:config).and_return(config)
+          end
+
+          it 'is a CLI Workflow' do
+            expect(workflow).to be_a(EY::Serverside::CLI::Workflows::Base)
+          end
+
+          it 'has a task name' do
+            expect(workflow.instance_eval {task_name}).
+              to eql('deploy')
+          end
+
+          describe '#perform' do
+            let(:perform) {workflow.perform}
+
+            before(:each) do
+              allow(workflow).to receive(:propagate_serverside)
+              allow(workflow).to receive(:deployer).and_return(deployer)
+              allow(deployer).to receive(:deploy)
+            end
+
+            it 'propagates serverside' do
+              expect(workflow).to receive(:propagate_serverside)
+
+              perform
+            end
+
+            it 'disables maintenance mode for the app' do
+              expect(workflow).to receive(:deployer).and_return(deployer)
+              expect(deployer).to receive(:deploy)
+              perform
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/cli/workflows/disabling_maintenance_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/cli/workflows/disabling_maintenance'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+        describe DisablingMaintenance do
+          let(:config) {Object.new}
+          let(:shell) {Object.new}
+          let(:options) {{}}
+          let(:maintenance) {Object.new}
+          let(:workflow) {described_class.new(options)}
+
+          before(:each) do
+            allow(shell).to receive(:fatal)
+            allow(shell).to receive(:debug)
+
+            allow(config).to receive(:verbose)
+            allow(config).to receive(:app)
+
+            allow(workflow).to receive(:shell).and_return(shell)
+            allow(workflow).to receive(:config).and_return(config)
+          end
+
+          it 'is a CLI Workflow' do
+            expect(workflow).to be_a(EY::Serverside::CLI::Workflows::Base)
+          end
+
+          it 'has a task name' do
+            expect(workflow.instance_eval {task_name}).
+              to eql('disable_maintenance')
+          end
+
+          describe '#perform' do
+            let(:perform) {workflow.perform}
+
+            before(:each) do
+              allow(workflow).to receive(:propagate_serverside)
+              allow(workflow).to receive(:maintenance).and_return(maintenance)
+              allow(maintenance).to receive(:manually_disable)
+            end
+
+            it 'propagates serverside' do
+              expect(workflow).to receive(:propagate_serverside)
+
+              perform
+            end
+
+            it 'disables maintenance mode for the app' do
+              expect(workflow).to receive(:maintenance).and_return(maintenance)
+              expect(maintenance).to receive(:manually_disable)
+              perform
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/cli/workflows/enabling_maintenance_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/cli/workflows/enabling_maintenance'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+        describe EnablingMaintenance do
+          let(:config) {Object.new}
+          let(:shell) {Object.new}
+          let(:options) {{}}
+          let(:maintenance) {Object.new}
+          let(:workflow) {described_class.new(options)}
+
+          before(:each) do
+            allow(shell).to receive(:fatal)
+            allow(shell).to receive(:debug)
+
+            allow(config).to receive(:verbose)
+            allow(config).to receive(:app)
+
+            allow(workflow).to receive(:shell).and_return(shell)
+            allow(workflow).to receive(:config).and_return(config)
+          end
+
+          it 'is a CLI Workflow' do
+            expect(workflow).to be_a(EY::Serverside::CLI::Workflows::Base)
+          end
+
+          it 'has a task name' do
+            expect(workflow.instance_eval {task_name}).
+              to eql('enable_maintenance')
+          end
+
+          describe '#perform' do
+            let(:perform) {workflow.perform}
+
+            before(:each) do
+              allow(workflow).to receive(:propagate_serverside)
+              allow(workflow).to receive(:maintenance).and_return(maintenance)
+              allow(maintenance).to receive(:manually_enable)
+            end
+
+            it 'propagates serverside' do
+              expect(workflow).to receive(:propagate_serverside)
+
+              perform
+            end
+
+            it 'enables maintenance mode for the app' do
+              expect(workflow).to receive(:maintenance).and_return(maintenance)
+              expect(maintenance).to receive(:manually_enable)
+              perform
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/cli/workflows/helpers_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/cli/workflows/helpers'
+
+class Helpful
+  include EY::Serverside::CLI::Workflows::Helpers
+end
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+        describe Helpers do
+          let(:config) {Object.new}
+          let(:shell) {Object.new}
+          let(:servers) {Object.new}
+          let(:workflow) {Helpful.new}
+
+          before(:each) do
+            allow(shell).to receive(:fatal)
+            allow(shell).to receive(:debug)
+
+            allow(config).to receive(:verbose)
+            allow(config).to receive(:app)
+
+            allow(workflow).to receive(:shell).and_return(shell)
+            allow(workflow).to receive(:config).and_return(config)
+            allow(workflow).to receive(:servers).and_return(servers)
+          end
+
+          describe '#deployer' do
+            let(:result) {Object.new}
+            let(:deployer) {workflow.deployer}
+
+            it 'is a Deploy for our workflow' do
+              expect(EY::Serverside::Deploy).
+                to receive(:new).
+                with(servers, config, shell).
+                and_return(result)
+
+              expect(deployer).to eql(result)
+            end
+          end
+
+          describe '#maintenance' do
+            let(:result) {Object.new}
+            let(:maintenance) {workflow.maintenance}
+
+            it 'is a Maintenance for our workflow' do
+              expect(EY::Serverside::Maintenance).
+                to receive(:new).
+                with(servers, config, shell).
+                and_return(result)
+
+              expect(maintenance).to eql(result)
+            end
+          end
+
+
+        end
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/cli/workflows/rolling_back_applications_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/cli/workflows/rolling_back_applications'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+        describe RollingBackApplications do
+          let(:config) {Object.new}
+          let(:shell) {Object.new}
+          let(:options) {{}}
+          let(:deployer) {Object.new}
+          let(:workflow) {described_class.new(options)}
+
+          before(:each) do
+            allow(shell).to receive(:fatal)
+            allow(shell).to receive(:debug)
+
+            allow(config).to receive(:verbose)
+            allow(config).to receive(:app)
+
+            allow(workflow).to receive(:shell).and_return(shell)
+            allow(workflow).to receive(:config).and_return(config)
+          end
+
+          it 'is a CLI Workflow' do
+            expect(workflow).to be_a(EY::Serverside::CLI::Workflows::Base)
+          end
+
+          it 'has a task name' do
+            expect(workflow.instance_eval {task_name}).
+              to eql('rollback')
+          end
+
+          describe '#perform' do
+            let(:perform) {workflow.perform}
+
+            before(:each) do
+              allow(workflow).to receive(:propagate_serverside)
+              allow(workflow).to receive(:deployer).and_return(deployer)
+              allow(deployer).to receive(:rollback)
+            end
+
+            it 'propagates serverside' do
+              expect(workflow).to receive(:propagate_serverside)
+
+              perform
+            end
+
+            it 'disables maintenance mode for the app' do
+              expect(workflow).to receive(:deployer).and_return(deployer)
+              expect(deployer).to receive(:rollback)
+              perform
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/cli/workflows/showing_maintenance_status_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/cli/workflows/showing_maintenance_status'
+
+module EY
+  module Serverside
+    module CLI
+      module Workflows
+        describe ShowingMaintenanceStatus do
+          let(:config) {Object.new}
+          let(:shell) {Object.new}
+          let(:options) {{}}
+          let(:maintenance) {Object.new}
+          let(:workflow) {described_class.new(options)}
+
+          before(:each) do
+            allow(shell).to receive(:fatal)
+            allow(shell).to receive(:debug)
+
+            allow(config).to receive(:verbose)
+            allow(config).to receive(:app)
+
+            allow(workflow).to receive(:shell).and_return(shell)
+            allow(workflow).to receive(:config).and_return(config)
+          end
+
+          it 'is a CLI Workflow' do
+            expect(workflow).to be_a(EY::Serverside::CLI::Workflows::Base)
+          end
+
+          it 'has a task name' do
+            expect(workflow.instance_eval {task_name}).
+              to eql('maintenance-status')
+          end
+
+          describe '#perform' do
+            let(:perform) {workflow.perform}
+
+            before(:each) do
+              allow(workflow).to receive(:maintenance).and_return(maintenance)
+              allow(maintenance).to receive(:status)
+            end
+
+            it 'does not propagate serverside' do
+              expect(workflow).not_to receive(:propagate_serverside)
+
+              perform
+            end
+
+            it 'calls status on the maintenance object for the workflow' do
+              expect(workflow).to receive(:maintenance).and_return(maintenance)
+              expect(maintenance).to receive(:status)
+              perform
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/cli/workflows_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/cli/workflows'
+
+module EY
+  module Serverside
+    module CLI
+      describe Workflows do
+        describe '.normalized' do
+          let(:expected) {:shabutie}
+          let(:workflow_name) {expected}
+
+          let(:normalized) {described_class.normalized(workflow_name)}
+
+          context 'when given a nil workflow name' do
+            let(:workflow_name) {nil}
+
+            it 'is nil' do
+              expect(normalized).to be_nil
+            end
+          end
+
+          context 'when given a workflow name string' do
+            let(:workflow_name) {'shabutie'}
+
+            it 'is the symbolized version of the string' do
+              expect(normalized).to eql(:shabutie)
+            end
+          end
+
+          context 'when given a workflow name symbol' do
+            it 'is returned unchanged' do
+              expect(normalized).to eql(expected)
+            end
+          end
+        end
+
+        describe '.resolve' do
+          let(:workflow_name) {nil}
+          let(:resolve) {described_class.resolve(workflow_name)}
+
+          context 'when given a nil workflow name' do
+            it 'is the base workflow' do
+              expect(resolve).to eql(described_class::Base)
+            end
+          end
+
+          context 'when given an unknown workflow name' do
+            let(:workflow_name) {:john_q_public}
+
+            it 'is the base workflow' do
+              expect(resolve).to eql(described_class::Base)
+            end
+          end
+
+          context 'when given a known workflow name' do
+            it 'is the requested workflow' do
+              described_class::DEFINED.each_pair do |workflow_name, workflow|
+                expect(described_class.resolve(workflow_name)).to eql(workflow)
+              end
+            end
+          end
+        end
+
+        describe '.perform' do
+          let(:resolved) {Object.new}
+          let(:workflow_name) {:gandalf}
+          let(:options) {{}}
+
+          let(:perform) {described_class.perform(workflow_name, options)}
+
+          it 'performs the requested workflow' do
+            expect(described_class).
+              to receive(:resolve).
+              with(workflow_name).
+              and_return(resolved)
+
+            expect(resolved).to receive(:perform).with(options)
+
+            perform
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/dependency_manager/base_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/dependency_manager/base'
+
+module EY
+  module Serverside
+    class DependencyManager
+
+      describe Base do
+        let(:servers) {Object.new}
+        let(:config) {Object.new}
+        let(:shell) {Object.new}
+        let(:runner) {Object.new}
+
+        let(:manager) {described_class.new(servers, config, shell, runner)}
+
+        describe '.detect' do
+          let(:manager) {Object.new}
+          let(:detected) {false}
+          let(:result) {described_class.detect(servers, config, shell, runner)}
+
+          before(:each) do
+            allow(described_class).to receive(:new).and_return(manager)
+            allow(manager).to receive(:detected?).and_return(detected)
+          end
+
+          context 'when the manager can detect its dependency signature' do
+            let(:detected) {true}
+
+            it 'is a new instance of the class' do
+              expect(result).to eql(manager)
+            end
+          end
+
+          context 'when the manager cannot detect its dependency signature' do
+            let(:detected) {false}
+
+            it 'is nil' do
+              expect(result).to eql(nil)
+            end
+          end
+
+        end
+
+        describe '#detected?' do
+          let(:result) {manager.detected?}
+
+          it 'is false' do
+            expect(result).to eql(false)
+          end
+        end
+
+        describe '#check' do
+          let(:result) {manager.check}
+
+          it 'is nil' do
+            expect(result).to eql(nil)
+          end
+        end
+
+        describe '#install' do
+          let(:result) {manager.install}
+
+          it 'is nil' do
+            expect(result).to eql(nil)
+          end
+        end
+
+        describe '#uses_sqlite3?' do
+          let(:result) {manager.uses_sqlite3?}
+
+          it 'is nil' do
+            expect(result).to eql(nil)
+          end
+        end
+
+        describe '#rails_version' do
+          let(:result) {manager.rails_version}
+
+          it 'is nil' do
+            expect(result).to eql(nil)
+          end
+        end
+
+        describe '#show_ey_config_instructions' do
+          let(:result) {manager.show_ey_config_instructions}
+
+          it 'is nil' do
+            expect(result).to eql(nil)
+          end
+        end
+
+        describe '#paths' do
+          let(:paths) {Object.new}
+          let(:result) {manager.instance_eval {paths}}
+
+          before(:each) do
+            allow(config).to receive(:paths).and_return(paths)
+          end
+
+          it 'is the config paths' do
+            expect(result).to eql(paths)
+          end
+        end
+
+        describe '#on_roles' do
+          let(:result) {manager.instance_eval {on_roles}}
+
+          it 'is an array' do
+            expect(result).to be_a(Array)
+          end
+
+          it 'applies to app masters' do
+            expect(result).to include(:app_master)
+          end
+
+          it 'applies to app instances' do
+            expect(result).to include(:app)
+          end
+
+          it 'applies to solo instances' do
+            expect(result).to include(:solo)
+          end
+
+          it 'applies to util instances' do
+            expect(result).to include(:util)
+          end
+
+          it 'does not apply to database instances' do
+            expect(result).not_to include(:db_master)
+            expect(result).not_to include(:db_slave)
+          end
+        end
+
+      end
+
+    end
+  end
+end