substation 0.0.10.beta2 → 0.0.10

data/spec/unit/substation/processor/evaluator/handler_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator::Handler do
+  let(:object) { Class.new { include Processor::Evaluator::Handler }.new }
+  let(:output) { double }
+
+  describe '#error' do
+    subject { object.error(output) }
+
+    it { should eql(Processor::Evaluator::Result::Failure.new(output)) }
+  end
+
+  describe '#success' do
+    subject { object.success(output) }
+
+    it { should eql(Processor::Evaluator::Result::Success.new(output)) }
+  end
+end

data/spec/unit/substation/processor/evaluator/pivot_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator::Pivot do
+  describe '#call' do
+    subject { object.call(request) }
+
+    let(:klass) { described_class }
+
+    include_context 'Processor::Call'
+
+    context 'with a successful handler' do
+      before do
+        expect(decomposer).to receive(:call).with(request).and_return(decomposed)
+        expect(handler).to receive(:call).with(decomposed).and_return(handler_result)
+        expect(observers).to receive(:each).with(no_args).and_yield(observer)
+        expect(observer).to receive(:call).with(handler_result)
+        expect(handler_result).to receive(:success?)
+      end
+
+      it { should eql(handler_result) }
+    end
+
+    context 'with a failing handler' do
+      let(:handler_success) { false }
+      let(:response)        { Response::Failure.new(request, composed) }
+
+      before do
+        expect(decomposer).to receive(:call).with(request).and_return(decomposed)
+        expect(handler).to receive(:call).with(decomposed).and_return(handler_result)
+        expect(observers).to receive(:each).with(no_args).and_yield(observer)
+        expect(observer).to receive(:call).with(handler_result)
+        expect(handler_result).to receive(:success?)
+        expect(composer).to receive(:call).with(request, handler_output).and_return(composed)
+        expect(failure_chain).to receive(:call).with(response).and_return(failure_response)
+      end
+
+      it { should eql(failure_response) }
+    end
+  end
+end

data/spec/unit/substation/processor/evaluator/request_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator::Request do
+  describe '#call' do
+    it_behaves_like 'Processor::Evaluator#call' do
+      let(:klass) { described_class }
+    end
+  end
+end

data/spec/unit/substation/processor/evaluator/result/failure_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator::Result::Failure do
+  describe '#success?' do
+    subject { object.success? }
+
+    let(:object) { described_class.new(output) }
+    let(:output) { double }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/substation/processor/evaluator/result/success_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator::Result::Success, '#success?' do
+  describe '#success?' do
+    subject { object.success? }
+
+    let(:object) { described_class.new(output) }
+    let(:output) { double }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/substation/processor/evaluator/result_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator::Result do
+  describe '.new' do
+    subject { object.new(output) }
+
+    let(:output) { double }
+
+    it_behaves_like 'an abstract type'
+  end
+end

data/spec/unit/substation/processor/evaluator_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator do
+
+  describe '#call' do
+    it_behaves_like 'Processor::Evaluator#call' do
+      let(:klass) { Class.new(described_class) { include Processor::Incoming } }
+    end
+  end
+
+  describe '.new' do
+    subject { object.new }
+
+    it_behaves_like 'an abstract type'
+  end
+end

data/spec/unit/substation/processor/executor/null_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Executor::NULL do
+
+  let(:input)  { double('input') }
+  let(:output) { double('output') }
+
+  describe '#compose' do
+    subject { described_class.compose(input, output) }
+
+    it 'should return the output unaltered' do
+      expect(subject).to be(output)
+    end
+  end
+
+  describe '#decompose' do
+    subject { described_class.decompose(input) }
+
+    it 'should return the input unaltered' do
+      expect(subject).to be(input)
+    end
+  end
+end

data/spec/unit/substation/processor/executor_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Executor, '#compose' do
+  let(:input)  { double('input') }
+  let(:output) { double('output') }
+
+  describe '#compose' do
+    subject { executor.compose(input, output) }
+
+    include_context 'Processor::Executor#initialize'
+
+    before do
+      expect(composer).to receive(:call).with(input, output).and_return(composed)
+    end
+
+    it { should be(composed) }
+  end
+
+  describe '#decompose' do
+    subject { executor.decompose(input) }
+
+    include_context 'Processor::Executor#initialize'
+
+    before do
+      expect(decomposer).to receive(:call).with(input).and_return(decomposed)
+    end
+
+    it { should be(decomposed) }
+  end
+end

data/spec/unit/substation/processor/fallible_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Fallible do
+  describe '#with_failure_chain' do
+    subject { object.with_failure_chain(chain) }
+
+    include_context 'Processor#initialize'
+
+    let(:klass) {
+      Class.new {
+        include Processor::Incoming
+        include Processor::Fallible
+      }
+    }
+
+    let(:expected)        { klass.new(processor_name, handler, expected_config) }
+    let(:expected_config) { processor_config.with_failure_chain(chain) }
+    let(:chain)           { double }
+
+    it { should eql(expected) }
+  end
+end

data/spec/unit/substation/processor/incoming_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Incoming do
+  describe '#result' do
+    subject { object.result(response) }
+
+    include_context 'Request#initialize'
+    include_context 'Processor#initialize'
+
+    let(:klass) { Class.new { include Substation::Processor::Incoming } }
+    let(:response) { Response::Success.new(request, input) }
+
+    it { should eql(request) }
+  end
+end

data/spec/unit/substation/processor/nest/incoming_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Nest::Incoming do
+
+  describe '#call' do
+    subject { object.call(request) }
+
+    let(:klass) { described_class }
+    let(:composed_state) { double }
+
+    include_context 'Processor::Call'
+
+    before do
+      allow(decomposer).to receive(:call).with(request).and_return(decomposed)
+      allow(handler).to receive(:call).with(decomposed).and_return(state)
+      allow(observers).to receive(:each).with(no_args).and_yield(observer)
+      allow(observer).to receive(:call).with(state)
+      allow(composer).to receive(:call).with(request, state) { composed_state }
+    end
+
+    context 'with a request' do
+      let(:state)      { Request.new(:test, double, data) }
+      let(:data)       { double('data') }
+      let(:first_pass) { request.success(data) }
+
+      before do
+        allow(composer).to receive(:call).with(request, first_pass) { composed_state }
+      end
+
+      it { should eql(request.success(composed_state)) }
+    end
+
+    context 'with a successful response' do
+      let(:state) { Response::Success.new(request, {}) }
+
+      it { should eql(request.success(composed_state)) }
+    end
+
+    context 'with a failure response' do
+      let(:state) { Response::Failure.new(request, {}) }
+
+      it { should eql(request.error(composed_state)) }
+    end
+
+    context 'with an unknown state' do
+      let(:state) { nil }
+
+      it 'raises RuntimeError' do
+        expect { subject }.to raise_error(RuntimeError, 'Illegal state returned from the invoked handler')
+      end
+    end
+  end
+
+end

data/spec/unit/substation/processor/nest_spec.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Nest do
+end

data/spec/unit/substation/processor/outgoing_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Outgoing, '#call' do
+  describe '#call' do
+    subject { object.call(request) }
+
+    include_context 'Request#initialize'
+    include_context 'Processor#initialize'
+
+    let(:klass) {
+      Class.new {
+        include Substation::Processor::Outgoing
+        def call(request)
+          response = request.success(request.input)
+          respond_with(response, :altered)
+        end
+      }
+    }
+
+    let(:response) { Response::Success.new(request, :altered) }
+
+    it { should eql(response) }
+  end
+
+  describe '#name' do
+    subject { object.name }
+
+    include_context 'Processor#initialize'
+
+    let(:klass) { Class.new { include Substation::Processor::Outgoing } }
+
+    it { should be(processor_name) }
+  end
+
+  describe '#success?' do
+    subject { object.success?(response) }
+
+    include_context 'Processor#initialize'
+
+    let(:klass)    { Class.new { include Substation::Processor::Outgoing } }
+    let(:response) { double }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/substation/processor/transformer/incoming_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Transformer::Incoming do
+  describe '#call' do
+    let(:klass) { described_class }
+
+    before do
+      expect(handler).to receive(:call).with(decomposed).and_return(handler_result)
+      expect(observers).to receive(:each).with(no_args).and_yield(observer)
+      expect(observer).to receive(:call).with(handler_result)
+    end
+
+    it_behaves_like 'Processor::Call::Incoming#call'
+  end
+end

data/spec/unit/substation/processor/transformer/outgoing_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Transformer::Outgoing do
+  describe '#call' do
+    let(:klass) { described_class }
+
+    before do
+      expect(handler).to receive(:call).with(decomposed).and_return(handler_result)
+      expect(observers).to receive(:each).with(no_args).and_yield(observer)
+      expect(observer).to receive(:call).with(handler_result)
+    end
+
+    it_behaves_like 'Processor::Call::Outgoing#call'
+  end
+end

data/spec/unit/substation/processor/wrapper/incoming_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Wrapper::Incoming do
+  describe '#call' do
+    let(:klass) { described_class }
+
+    before do
+      expect(handler).to receive(:new).with(decomposed).and_return(handler_result)
+    end
+
+    it_behaves_like 'Processor::Call::Incoming#call'
+  end
+end

data/spec/unit/substation/processor/wrapper/outgoing_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Wrapper::Outgoing do
+  describe '#call' do
+    let(:klass) { described_class }
+
+    before do
+      expect(handler).to receive(:new).with(decomposed).and_return(handler_result)
+    end
+
+    it_behaves_like 'Processor::Call::Outgoing#call'
+  end
+end

data/spec/unit/substation/processor/wrapper_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Wrapper do
+  describe '#call' do
+    it_behaves_like 'Processor::Call::Incoming#call' do
+      before do
+        expect(handler).to receive(:new).with(decomposed).and_return(handler_result)
+      end
+
+      let(:klass) {
+        Class.new {
+          include Processor::Incoming
+          include Processor::Wrapper
+
+          def call(request)
+            request.success(execute(request))
+          end
+        }
+      }
+    end
+  end
+end