engineyard-serverside 2.8.0.pre4 → 2.8.0

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/slug/source'
+
+module EY
+  module Serverside
+    module Slug
+      describe Source do
+        let(:servers) {[]}
+        let(:config) {Object.new}
+        let(:shell) {Object.new}
+
+        describe '.update' do
+          let(:input) {
+            {:servers => servers, :config => config, :shell => shell}
+          }
+
+          let(:update) {described_class.update(input)}
+
+          it 'updates with a new updater' do
+            result = Result.Success(nil)
+            updater = Object.new
+
+            expect(updater).
+              to receive(:update).
+              and_return(result)
+
+            expect(described_class::Updater).
+              to receive(:new).
+              with(input).
+              and_return(updater)
+
+            expect(update).to eql(result)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/engineyard-serverside/source_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+require 'engineyard-serverside/source'
+
+module EY
+  module Serverside
+
+    describe Source do
+      let(:source) {described_class.new(opts)}
+
+      before(:each) do
+        described_class.instance_eval do
+          @required_opts = nil
+        end
+      end
+
+      after(:each) do
+        described_class.instance_eval do
+          @required_opts = nil
+        end
+      end
+
+      describe '.new' do
+        let(:shell) {Object.new}
+
+        let(:result) {described_class.new(shell)}
+
+        it 'sets the shell to that provided' do
+          expect(result.shell).to eql(shell)
+        end
+
+        context 'when no options are provided' do
+          it 'sets the options to an empty hash' do
+            expect(result.opts).to eql({})
+          end
+        end
+
+        context 'when there are required options' do
+          let(:opts) {{}}
+          let(:result) {described_class.new(shell, opts)}
+
+          before(:each) do
+            described_class.instance_eval do
+              @required_opts = [:foo, :bar]
+            end
+          end
+
+          context 'that are missing' do
+            it 'raises an argument error' do
+              expect {result}.to raise_error(ArgumentError)
+            end
+          end
+
+          context 'that are satisfied' do
+            let(:opts) {{:foo => 'foo', :bar => 'bar'}}
+
+            it 'does not raise an error' do
+              expect {result}.not_to raise_error
+            end
+          end
+        end
+
+        context 'when options are provided' do
+          let(:opts) {{}}
+          let(:result) {described_class.new(shell, opts)}
+
+          context 'and a ref is provided' do
+            let(:ref) {1234}
+            let(:opts) {{:ref => ref}}
+
+            it 'stringifies the provided ref and saves it' do
+              expect(result.ref).to eql(ref.to_s)
+            end
+          end
+
+          context 'and no ref is provided' do
+            it 'saves a blank string' do
+              expect(result.ref).to eql('')
+            end
+          end
+
+          context 'and a uri is provided' do
+            let(:uri) {'http://example.com'}
+            let(:opts) {{:uri => uri}}
+
+            it 'saves the provided uri' do
+              expect(result.uri).to eql(uri)
+            end
+          end
+
+          context 'and no uri is provided' do
+            it 'saves a nil uri' do
+              expect(result.uri).to be_nil
+            end
+          end
+
+          context 'and a repository cache is provided' do
+            let(:repository_cache) {'/path/to/repo/cache'}
+            let(:opts) {{:repository_cache => repository_cache}}
+
+            it 'saves the provided repository_cache as a source_cache path' do
+              expect(result.source_cache).to eql(Pathname.new(repository_cache))
+            end
+          end
+
+          context 'and no repository cache is provided' do
+            it 'saves a nil source_cache' do
+              expect(result.source_cache).to be_nil
+            end
+          end
+        end
+      end
+
+      describe '.required_opts' do
+        context 'without arguments' do
+          let(:result) {described_class.required_opts}
+
+          context 'when there are required options' do
+            before(:each) do
+              described_class.instance_eval do
+                @required_opts = [:foo, :bar]
+              end
+            end
+
+            it 'is the required option array' do
+              expect(result).to eql([:foo, :bar])
+            end
+          end
+
+          context 'when there are no required options' do
+            it 'is nil' do
+              expect(result).to be_nil
+            end
+          end
+        end
+      end
+
+      describe '.require_opts' do
+        let(:result) {described_class.require_opts(:foo, :bar)}
+
+        context 'when there are no required options' do
+          it 'sets the required opts to those provided' do
+            expect(described_class.required_opts).to be_nil
+
+            result
+
+            expect(described_class.required_opts).to eql([:foo, :bar])
+          end
+        end
+
+        context 'when there are already required options' do
+          before(:each) do
+            described_class.instance_eval do
+              @required_opts = [:bob]
+            end
+          end
+
+          it 'adds the provided names to the required opts' do
+            expect(described_class.required_opts).to eql([:bob])
+
+            result
+
+            expect(described_class.required_opts).to eql([:bob, :foo, :bar])
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/spec/railway_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+require 'railway'
+
+class ComplicatedProcess
+  include Railway
+
+  step :step_1
+  step :step_2
+  step :step_3
+end
+
+class EmptyProcess
+  include Railway
+end
+
+describe Railway do
+  let(:steps) {[:step_1, :step_2, :step_3]}
+  let(:dummy) {ComplicatedProcess.new}
+
+  before(:each) do
+    steps.each do |step|
+      allow(dummy).to receive(step).and_return(Result.Success(nil))
+    end
+  end
+
+  describe '#call' do
+    let(:input) {nil}
+    let(:result) {dummy.call(input)}
+
+    it 'has a default argument' do
+      expect {dummy.call}.not_to raise_error
+    end
+
+    it 'passes the output of one step to the next step as input' do
+      allow(dummy).to receive(:step_1).and_return('step 1')
+      expect(dummy).to receive(:step_2).with('step 1').and_return('step 2')
+      expect(dummy).to receive(:step_3).with('step 2').and_return('step 3')
+
+      result
+    end
+
+    context 'when all steps are successful' do
+      it 'executes all steps' do
+        steps.each do |step|
+          expect(dummy).to receive(step).and_return(Result.Success(nil))
+        end
+
+        result
+      end
+
+      it 'returns a success' do
+        expect(result).to be_a(Result::Success)
+      end
+    end
+
+    context 'when a step fails' do
+      let(:failing_step) {:step_1}
+      let(:failure) {Result.Failure(nil)}
+
+      before(:each) do
+        allow(dummy).to receive(:step_1).and_return(failure)
+      end
+
+      it 'executes all steps up to that step' do
+        expect(dummy).to receive(:step_1).and_return(failure)
+
+        result
+      end
+
+      it 'does not execute steps after the failing step' do
+        (steps - [failing_step]).each do |step|
+          expect(dummy).not_to receive(step)
+        end
+
+        result
+      end
+
+      it 'returns the failure' do
+        expect(result).to eql(failure)
+      end
+    end
+
+    context 'when a step returns something other than a result' do
+      before(:each) do
+        steps.each do |step|
+          allow(dummy).to receive(step).and_return(step.to_s)
+        end
+      end
+
+      it 'treats the return value as a Success' do
+        expect(dummy).to receive(:step_2).with('step_1').and_return('step_2')
+        expect(dummy).to receive(:step_3).with('step_2').and_return('step_3')
+
+        expect(result).to be_a(Result::Success)
+        expect(result.value).to eql('step_3')
+      end
+    end
+
+    context 'when a step raises an error' do
+      let(:failing_step) {:step_1}
+      let(:error) {RuntimeError.new('a big nasty error')}
+
+      before(:each) do
+        allow(dummy).to receive(:step_1).and_raise(error)
+      end
+
+      it 'treats the step as a failure' do
+        (steps - [failing_step]).each do |step|
+          expect(dummy).not_to receive(step)
+        end
+
+        expect(result).to be_a(Result::Failure)
+        expect(result.error).to eql(error)
+      end
+    end
+
+    context 'when there are no steps' do
+      let(:dummy) {EmptyProcess.new}
+
+      it 'is a failure' do
+        expect(result).to be_a(Result::Failure)
+      end
+
+      it 'has an error regarding the lack of steps' do
+        expect(result.error).to eql('No steps')
+      end
+    end
+  end
+end

data/spec/result/failure_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+require 'result/failure'
+
+module Result
+  describe Failure do
+    let(:dummy) {Object.new}
+    let(:wrapped) {3}
+    let(:result) {described_class.new(wrapped)}
+
+    before(:each) do
+      allow(dummy).to receive(:process)
+    end
+
+    it 'is a result' do
+      expect(result).to be_a(Result::Base)
+    end
+
+    it 'is frozen' do
+      expect(result).to be_frozen
+    end
+
+    describe '#success?' do
+      let(:success) {result.success?}
+
+      it 'is false' do
+        expect(success).to eql(false)
+      end
+    end
+
+    describe '#failure?' do
+      let(:failure) {result.failure?}
+
+      it 'is true' do
+        expect(failure).to eql(true)
+      end
+    end
+
+    describe '#value' do
+      let(:value) {result.value}
+
+      it 'raises an exception' do
+        expect {value}.to raise_exception
+      end
+    end
+
+    describe '#error' do
+      let(:error) {result.error}
+
+      it 'is the wrapped error' do
+        expect(error).to eql(wrapped)
+      end
+    end
+
+    describe '#and_then' do
+      it 'does not execute the given block' do
+        expect(dummy).not_to receive(:process)
+
+        result.and_then {|v| dummy.process(v)}
+      end
+
+      it 'is the failure itself' do
+        actual = result.and_then {|v| v}
+
+        expect(actual).to eql(result)
+      end
+    end
+
+    describe '#or_else' do
+
+      it 'yields the wrapped value to the block' do
+        expect(dummy).to receive(:process).with(wrapped)
+
+        result.or_else {|v| dummy.process(v)}
+      end
+
+      it 'is the result of the block' do
+        actual = result.or_else {|v| v + 1}
+
+        expect(actual).to eql(wrapped + 1)
+      end
+    end
+
+    describe '#on_success' do
+      it 'does not call the block' do
+        expect(dummy).not_to receive(:process)
+
+        result.on_success {|v| dummy.process(v)}
+      end
+
+      it 'is the failure itself' do
+        actual = result.on_success {|v| v}
+
+        expect(actual).to eql(result)
+      end
+    end
+
+    describe '#on_failure' do
+      it 'yields the wrapped value to the block' do
+        expect(dummy).to receive(:process).with(wrapped)
+
+        result.on_failure {|v| dummy.process(v)}
+      end
+
+      it 'is the failure itself' do
+        actual = result.on_failure {|v| v}
+
+        expect(actual).to eql(result)
+      end
+    end
+
+  end
+end