substation 0.0.10.beta2 → 0.0.10

data/spec/unit/substation/chain_spec.rb

@@ -0,0 +1,303 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain do
+  describe '#call' do
+
+    subject { object.call(request) }
+
+    include_context 'Request#initialize'
+
+    let(:object)          { described_class.new(processors, exception_chain) }
+    let(:exception_chain) { double(:call => response) }
+    let(:processors)      { [ processor_1, processor_2, processor_3 ] }
+
+    let(:processor_1_name) { double }
+    let(:processor_2_name) { double }
+    let(:processor_3_name) { double }
+
+    let(:processor_config) { Processor::Config.new(handler, failure_chain, executor) }
+    let(:handler)          { double('handler') }
+    let(:failure_chain)    { double(:call => failure_response) }
+    let(:failure_response) { double }
+    let(:executor)         { Processor::Executor::NULL }
+
+    context 'when all processors are successful' do
+      let(:processor_1) {
+        Class.new {
+          include Substation::Processor::Incoming
+          def call(request)
+            request.success(:success_1)
+          end
+        }.new(processor_1_name, handler, processor_config)
+      }
+
+      let(:processor_2) {
+        Class.new {
+          include Substation::Processor::Pivot
+          def call(request)
+            request.success(:success_2)
+          end
+        }.new(processor_2_name, handler, processor_config)
+      }
+
+      let(:processor_3) {
+        Class.new {
+          include Substation::Processor::Outgoing
+          def call(response)
+            respond_with(response, :success_3)
+          end
+        }.new(processor_3_name, handler, processor_config)
+      }
+
+      let(:response)        { Response::Success.new(current_request, :success_3) }
+      let(:current_request) { Request.new(name, env, :success_1) }
+
+      it { should eql(response) }
+    end
+
+    context 'when an incoming processor is not successful' do
+
+      let(:processor_2) {
+        Class.new {
+          include Substation::Processor::Pivot
+          def call(request)
+            request.success(:success_1)
+          end
+        }.new(processor_2_name, handler, processor_config)
+      }
+
+      let(:processor_3) {
+        Class.new {
+          include Substation::Processor::Outgoing
+          def call(response)
+            respond_with(response, :success_3)
+          end
+        }.new(processor_3_name, handler, processor_config)
+      }
+
+      let(:response_class) { Response::Failure }
+
+      context 'because it returned a failure response' do
+        let(:processor_1) {
+          Class.new {
+            include Substation::Processor::Incoming
+            def call(request)
+              request.error(:error_1)
+            end
+          }.new(processor_1_name, handler, processor_config)
+        }
+
+        let(:response) { Response::Failure.new(request, :error_1) }
+
+        it { should eql(response) }
+      end
+
+      context 'because it raised an uncaught exception' do
+        let(:processor_1) {
+          Class.new {
+            include Substation::Processor::Incoming
+            def call(request)
+              raise RuntimeError, 'exception_1'
+            end
+          }.new(processor_1_name, handler, processor_config)
+        }
+
+        let(:response) { Response::Exception.new(request, data) }
+        let(:data)     { Response::Exception::Output.new(input, RuntimeError.new('exception_1')) }
+
+        it { should eql(response) }
+
+        it 'wraps the original exception instance' do
+          expect(subject.output.exception.message).to eql('exception_1')
+        end
+
+        it 'calls the failure chain' do
+          expect(exception_chain).to receive(:call).with(response)
+          subject
+        end
+      end
+    end
+
+    context 'when the pivot processor is not successful' do
+      let(:processor_1) {
+        Class.new {
+          include Substation::Processor::Incoming
+          def call(request)
+            request.success(:success_1)
+          end
+        }.new(processor_1_name, handler, processor_config)
+      }
+
+      let(:processor_3) {
+        Class.new {
+          include Substation::Processor::Outgoing
+          def call(response)
+            response
+          end
+        }.new(processor_3_name, handler, processor_config)
+      }
+
+      let(:response_class) { Response::Failure }
+
+      context 'because it returned a failure response' do
+        let(:processor_2) {
+          Class.new {
+            include Substation::Processor::Pivot
+            def call(request)
+              request.error(:error_2)
+            end
+          }.new(processor_2_name, handler, processor_config)
+        }
+
+        let(:response)        { Response::Failure.new(current_request, :error_2) }
+        let(:current_request) { Request.new(name, env, :success_1) }
+
+        it { should eql(response) }
+      end
+
+      context 'because it raised an uncaught exception' do
+        let(:processor_2) {
+          Class.new {
+            include Substation::Processor::Pivot
+            def call(request)
+              raise RuntimeError, 'exception_2'
+            end
+          }.new(processor_2_name, handler, processor_config)
+        }
+
+        let(:response)        { Response::Exception.new(request.to_request(:success_1), data) }
+        let(:data)            { Response::Exception::Output.new(:success_1, RuntimeError.new('exception_2')) }
+        let(:current_request) { Request.new(name, env, :success_1) }
+
+        it { should eql(response) }
+
+        it 'wraps the original exception instance' do
+          expect(subject.output.exception.message).to eql('exception_2')
+        end
+
+        it 'calls the failure chain' do
+          expect(exception_chain).to receive(:call).with(response)
+          subject
+        end
+      end
+    end
+
+    context 'when an outgoing processor is not successful' do
+      let(:processor_1) {
+        Class.new {
+          include Substation::Processor::Incoming
+          def call(request)
+            request.success(:success_1)
+          end
+        }.new(processor_1_name, handler, processor_config)
+      }
+
+      let(:processor_2) {
+        Class.new {
+          include Substation::Processor::Pivot
+          def call(response)
+            response.success(:success_2)
+          end
+        }.new(processor_2_name, handler, processor_config)
+      }
+
+      let(:response_class) { Response::Failure }
+
+      context 'because it raised an uncaught exception' do
+        let(:processor_3) {
+          Class.new {
+            include Substation::Processor::Outgoing
+            def call(response)
+              raise RuntimeError, 'exception_3'
+            end
+          }.new(processor_3_name, handler, processor_config)
+        }
+
+        let(:response)         { Response::Exception.new(request.to_request(:success_2), data) }
+        let(:data)             { Response::Exception::Output.new(:success_2, RuntimeError.new('exception_3')) }
+        let(:current_request)  { Request.new(name, env, :success_1) }
+        let(:current_response) { Response::Success.new(current_request, :success_2) }
+
+        it { should eql(response) }
+
+        it 'wraps the original exception instance' do
+          expect(subject.output.exception.message).to eql('exception_3')
+        end
+
+        it 'calls the failure chain' do
+          expect(exception_chain).to receive(:call).with(response)
+          subject
+        end
+      end
+    end
+  end
+
+  describe '#each' do
+    subject { object.each { |tuple| yields << processor } }
+
+    let(:object)     { described_class.new(processors, described_class::EMPTY) }
+    let(:processors) { [ processor ] }
+    let(:processor)  { Spec::FAKE_PROCESSOR }
+    let(:yields)     { [] }
+
+    before do
+      expect(object).to be_instance_of(described_class)
+    end
+
+    it_should_behave_like 'an #each method'
+
+    it 'yields only processors' do
+      subject
+      yields.each { |processor| expect(processor).to be_instance_of(Spec::Processor) }
+    end
+
+    it 'yields only processors with the expected handler' do
+      expect { subject }.to change { yields.dup }
+        .from([])
+        .to([ processor ])
+    end
+  end
+
+  describe Chain do
+    subject { described_class.new(processors, described_class::EMPTY) }
+
+    let(:processors) { [ processor ] }
+    let(:processor)  { Spec::FAKE_PROCESSOR }
+
+    before do
+      expect(subject).to be_instance_of(described_class)
+    end
+
+    it { should be_kind_of(Enumerable) }
+  end
+
+  describe '.exception_response' do
+    subject { described_class.exception_response(state, data, exception) }
+
+    include_context 'Request#initialize'
+
+    let(:data)           { double('data') }
+    let(:exception)      { double('exception') }
+    let(:exception_data) { Response::Exception::Output.new(data, exception) }
+
+    let(:expected)         { Response::Exception.new(expected_request, exception_data) }
+
+    context 'when a request is passed as current state' do
+      let(:state)            { request }
+      let(:expected_request) { request.to_request(data) }
+
+      it { should eql(expected) }
+    end
+
+    context 'when a response is passed as current state' do
+      let(:state)            { response }
+      let(:expected_request) { response.to_request(data) }
+      let(:response)         { Response::Failure.new(request, output) }
+      let(:output)           { double('output') }
+
+      it { should eql(expected) }
+    end
+  end
+end

data/spec/unit/substation/dispatcher_spec.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Dispatcher do
+  describe '#call' do
+
+    subject { object.call(name, input) }
+
+    include_context 'Request#initialize'
+
+    let(:object)  { described_class.new(config, env) }
+    let(:config)  { DSL::Registry.new(guard, :test => Spec::Action::Success) }
+    let(:guard)   { double('guard') }
+
+    let(:expected_response) do
+      Spec::Action::Success.call(request)
+    end
+
+    context 'when the action is registered' do
+      let(:name) { :test }
+
+      it { should eql(expected_response) }
+    end
+
+    context 'when the action is not registered' do
+      let(:name) { :unknown }
+
+      specify do
+        expect { subject }.to raise_error(described_class::UnknownActionError)
+      end
+    end
+  end
+
+  describe '.new_registry' do
+    subject { described_class.new_registry }
+
+    let(:expected) { DSL::Registry.new(described_class::GUARD) }
+
+    it { should eql(expected) }
+  end
+
+  describe '#include?' do
+
+    subject { object.include?(name) }
+
+    let(:object)  { described_class.new(actions, env) }
+    let(:actions) { Hash[action => double('action')] }
+    let(:action)  { double('action') }
+    let(:env)     { double('env') }
+
+    context 'when the action is registered' do
+      let(:name) { action }
+
+      it 'returns true' do
+        expect(subject).to be(true)
+      end
+    end
+
+    context 'when the action is not registered' do
+      let(:name) { :unknown }
+
+      it 'returns false' do
+        expect(subject).to be(false)
+      end
+    end
+  end
+end

data/spec/unit/substation/dsl/guard_spec.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe DSL::Guard do
+  describe '#call' do
+    subject { object.call(name, registry) }
+
+    let(:name)     { double('name') }
+    let(:registry) { double('registry') }
+
+    context 'when no reserved names are given' do
+      let(:object) { described_class.new }
+
+      context 'when the given name is valid' do
+        let(:name) { :test }
+
+        before do
+          expect(registry).to receive(:include?).with(name).and_return(false)
+        end
+
+        it 'raises no error' do
+          expect { subject }.to_not raise_error
+        end
+      end
+
+      context 'when the given name is already registered' do
+        let(:name) { :test }
+        let(:msg)  { described_class::ALREADY_REGISTERED_MSG % name.inspect }
+
+        before do
+          expect(registry).to receive(:include?).with(name).and_return(true)
+        end
+
+        it 'raises ReservedNameError' do
+          expect { subject }.to raise_error(AlreadyRegisteredError, msg)
+        end
+      end
+    end
+
+    context 'when reserved names are given' do
+      let(:object)         { described_class.new(reserved_names) }
+      let(:reserved_names) { double('reserved_names') }
+
+      before do
+        expect(registry).to receive(:include?).with(name).and_return(false)
+      end
+
+      context 'when the given name is not reserved' do
+        before do
+          expect(reserved_names).to receive(:include?).with(name).and_return(false)
+        end
+
+        it 'raises no error' do
+          expect { subject }.to_not raise_error
+        end
+      end
+
+      context 'when the given name is reserved' do
+        let(:msg)  { described_class::RESERVED_NAME_MSG % name.inspect }
+
+        before do
+          expect(reserved_names).to receive(:include?).with(name).and_return(true)
+        end
+
+        it 'raises ReservedNameError' do
+          expect { subject }.to raise_error(ReservedNameError, msg)
+        end
+      end
+    end
+  end
+end

data/spec/unit/substation/dsl/registry_spec.rb

@@ -0,0 +1,181 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe DSL::Registry do
+  describe '#each' do
+    subject { object.each(&block) }
+
+    let(:object)  { described_class.new(guard, entries) }
+    let(:guard)   { double('guard') }
+    let(:entries) { { name => entry } }
+    let(:name)    { double('name') }
+    let(:entry)   { double('entry') }
+    let(:block)   { ->(_) { } }
+
+    it_should_behave_like 'an #each method'
+
+    it { should be_kind_of(Enumerable) }
+
+    it 'yields all entries' do
+      expect { |block| object.each(&block) }.to yield_successive_args([name, entry])
+    end
+  end
+
+  describe '#[]=' do
+    subject { object[name] = expected }
+
+    let(:object)         { described_class.new(guard) }
+    let(:guard)          { DSL::Guard.new(reserved_names) }
+    let(:reserved_names) { EMPTY_ARRAY }
+    let(:expected)       { double('expected') }
+    let(:name)           { double('name', :to_sym => coerced_name) }
+    let(:coerced_name)   { double('coerced_name') }
+
+    context 'when name is not yet registered' do
+      it 'returns registered object' do
+        should be(expected)
+      end
+
+      it 'registers given object' do
+        subject
+        expect(object.fetch(name)).to be(expected)
+      end
+    end
+
+    context 'when name is already registered' do
+      let(:msg) { DSL::Guard::ALREADY_REGISTERED_MSG % coerced_name.inspect }
+
+      before { object[name] = expected }
+
+      specify { expect { subject }.to raise_error(AlreadyRegisteredError, msg) }
+    end
+
+    context 'when name is reserved' do
+      let(:msg)            { DSL::Guard::RESERVED_NAME_MSG % coerced_name.inspect }
+      let(:reserved_names) { [coerced_name] }
+
+      specify { expect { subject }.to raise_error(ReservedNameError, msg) }
+    end
+  end
+
+  describe '#fetch' do
+
+    let(:object)       { described_class.new(guard, entries) }
+    let(:guard)        { double('guard') }
+    let(:name)         { double('name') }
+    let(:coerced_name) { double('coerced_name') }
+
+    before do
+      expect(name).to receive(:to_sym).and_return(coerced_name)
+    end
+
+    context 'when name is not yet registered' do
+      let(:entries) { {} }
+
+      context 'and a block is given' do
+        subject { object.fetch(name, &block) }
+
+        let(:block)          { ->(_) { block_return } }
+        let(:block_return)   { double('block_return') }
+
+        it { should be(block_return) }
+      end
+
+      context 'and no block is given' do
+        subject { object.fetch(name) }
+
+        it 'should behave like Hash#fetch' do
+          expect { subject }.to raise_error(KeyError)
+        end
+      end
+    end
+
+    context 'when name is already registered' do
+      subject { object.fetch(name) }
+
+      let(:entries)  { { coerced_name => expected } }
+      let(:expected) { double('expected') }
+
+      it { should be(expected) }
+    end
+  end
+
+  describe '#include?' do
+    subject { object.include?(name) }
+
+    let(:object)       { described_class.new(guard, entries) }
+    let(:guard)        { double('guard') }
+    let(:name)         { double('name') }
+    let(:coerced_name) { double('coerced_name') }
+
+    before do
+      expect(name).to receive(:to_sym).with(no_args).and_return(coerced_name)
+    end
+
+    context 'when name is included' do
+      let(:entries)  { { coerced_name => data } }
+      let(:data)     { double('data') }
+
+      it { should be(true) }
+    end
+
+    context 'when name is not included' do
+      let(:entries) { {} }
+
+      it { should be(false) }
+    end
+  end
+
+  describe '#keys' do
+    subject { object.keys }
+
+    let(:object)  { described_class.new(guard, entries) }
+    let(:guard)   { double('guard') }
+    let(:entries) { { key => value } }
+    let(:key)     { double('key') }
+    let(:value)   { double('value') }
+
+    it { should eql([key]) }
+  end
+
+  describe '#merge' do
+    subject { object.merge(other) }
+
+    let(:other)        { described_class.new(guard, entries) }
+    let(:entries)      { { coerced_name => data } }
+    let(:data)         { double('data') }
+
+    let(:guard)        { double('guard') }
+    let(:name)         { double('name') }
+    let(:coerced_name) { double('coerced_name') }
+
+    before do
+      expect(coerced_name).to receive(:to_sym).with(no_args).and_return(coerced_name)
+    end
+
+    context 'when other contains equally named objects' do
+      before do
+        expect(guard).to receive(:call).with(coerced_name, entries).and_raise(RuntimeError)
+      end
+
+      let(:object) { described_class.new(guard, entries) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(RuntimeError)
+      end
+    end
+
+    context 'when other only contains new names as keys' do
+      before do
+        expect(guard).to receive(:call).with(coerced_name, {})
+      end
+
+      let(:object)   { described_class.new(guard) }
+      let(:expected) { described_class.new(guard, entries) }
+
+      it { should eql(expected) }
+      it { should_not be(object) }
+    end
+  end
+end