substation 0.0.8 → 0.0.9

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

@@ -1,17 +1,19 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Substation::Environment::DSL, '#registry' do
   subject { object.registry }
 
-  context "when a block is given" do
+  context 'when a block is given' do
     let(:object)   { described_class.new(&block) }
-    let(:block)    { lambda { |_| register :test, Spec::Processor } }
+    let(:block)    { ->(_) { register :test, Spec::Processor } }
     let(:expected) { { :test => Spec::Processor } }
 
     it { should eql(expected) }
   end
 
-  context "when no block is given" do
+  context 'when no block is given' do
     let(:object) { described_class.new }
 
     it { should eql({}) }

data/spec/unit/substation/environment/equalizer_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Substation::Environment, 'equalizer behavior' do
+  subject { object == other }
+
+  let(:object) { described_class.new(registry, dsl) }
+  let(:other)  { described_class.new(other_registry, dsl) }
+
+  let(:registry) { mock }
+  let(:dsl)      { mock }
+
+  context 'with an equal registry' do
+    let(:other_registry) { registry }
+
+    it { should be(true) }
+  end
+
+  context 'with a different registry' do
+    let(:other_registry) { mock }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/substation/observer/chain/call_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Observer::Chain, '#call' do

data/spec/unit/substation/observer/class_methods/coerce_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Observer, '.coerce' do

data/spec/unit/substation/observer/null/call_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Observer::NULL, '#call' do

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

@@ -5,21 +5,31 @@ require 'spec_helper'
 describe Processor::Evaluator, '#call' do
   subject { object.call(request) }
 
-  let(:object)  { described_class.new(Spec::Handler::Evaluator.new) }
-  let(:request) { Request.new(env, input) }
-  let(:env)     { mock }
+  let(:object)           { klass.new(processor_name, handler, failure_chain) }
+  let(:processor_name)   { mock }
+  let(:klass)            { Class.new(described_class) { include Processor::Incoming } }
+  let(:failure_chain)    { mock(:call => failure_response) }
+  let(:failure_response) { mock }
+  let(:request)          { Request.new(action_name, env, input) }
+  let(:action_name)      { mock }
+  let(:env)              { mock }
+  let(:input)            { mock }
 
-  context "when evaluation is successful" do
-    let(:input)    { :success }
-    let(:response) { Response::Success.new(request, input) }
+  context 'with a successful handler' do
+    let(:handler)  { Spec::Action::Success }
+    let(:response) { Response::Success.new(request, Spec.response_data) }
 
     it { should eql(response) }
   end
 
-  context "when evaluation is not successful" do
-    let(:input)    { :invalid }
-    let(:response) { Response::Failure.new(request, :failure) }
+  context 'with a failing handler' do
+    let(:handler)  { Spec::Action::Failure }
+    let(:response) { Response::Failure.new(request, Spec.response_data) }
 
-    it { should eql(response) }
+    before do
+      failure_chain.should_receive(:call).with(response).and_return(failure_response)
+    end
+
+    it { should eql(failure_response) }
   end
 end

data/spec/unit/substation/processor/evaluator/class_methods/new_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator, '.new' do
+  subject { object.new }
+
+  it_behaves_like 'an abstract type'
+end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator::Data, '#call' do
+  subject { object.call(request) }
+
+  let(:object)           { described_class.new(processor_name, handler, failure_chain) }
+  let(:processor_name)   { mock }
+  let(:failure_chain)    { mock(:call => failure_response) }
+  let(:failure_response) { mock }
+  let(:handler)          { Spec::Handler::Evaluator }
+  let(:request)          { Request.new(action_name, env, input) }
+  let(:action_name)      { mock }
+  let(:env)              { mock }
+
+  context 'with a successful handler' do
+    let(:input)    { :success }
+    let(:response) { request.success(input) }
+
+    it { should eql(response) }
+  end
+
+  context 'with a failing handler' do
+    let(:input)    { :foo }
+    let(:response) { request.error(:failure) }
+
+    before do
+      failure_chain.should_receive(:call).with(response).and_return(failure_response)
+    end
+
+    it { should eql(failure_response) }
+  end
+end

data/spec/unit/substation/processor/evaluator/pivot/call_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator::Pivot, '#call' do
+  subject { object.call(request) }
+
+  let(:object)           { described_class.new(processor_name, handler, failure_chain) }
+  let(:processor_name)   { mock }
+  let(:failure_chain)    { mock(:call => failure_response) }
+  let(:failure_response) { mock }
+  let(:request)          { Request.new(action_name, env, input) }
+  let(:action_name)      { mock }
+  let(:env)              { mock }
+  let(:input)            { mock }
+
+  context 'with a successful handler' do
+    let(:handler)  { Spec::Action::Success }
+    let(:response) { Response::Success.new(request, Spec.response_data) }
+
+    it { should eql(response) }
+  end
+
+  context 'with a failing handler' do
+    let(:handler)  { Spec::Action::Failure }
+    let(:response) { Response::Failure.new(request, Spec.response_data) }
+
+    before do
+      failure_chain.should_receive(:call).with(response).and_return(failure_response)
+    end
+
+    it { should eql(failure_response) }
+  end
+end

data/spec/unit/substation/processor/evaluator/request/call_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator::Request, '#call' do
+  subject { object.call(request) }
+
+  let(:object)           { described_class.new(processor_name, handler, failure_chain) }
+  let(:processor_name)   { mock }
+  let(:failure_chain)    { mock(:call => failure_response) }
+  let(:failure_response) { mock }
+  let(:request)          { Request.new(action_name, env, input) }
+  let(:action_name)      { mock }
+  let(:env)              { mock }
+  let(:input)            { mock }
+
+  context 'with a successful handler' do
+    let(:handler)  { Spec::Action::Success }
+    let(:response) { Response::Success.new(request, Spec.response_data) }
+
+    it { should eql(response) }
+  end
+
+  context 'with a failing handler' do
+    let(:handler)  { Spec::Action::Failure }
+    let(:response) { Response::Failure.new(request, Spec.response_data) }
+
+    before do
+      failure_chain.should_receive(:call).with(response).and_return(failure_response)
+    end
+
+    it { should eql(failure_response) }
+  end
+end

data/spec/unit/substation/processor/fallible/name_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Fallible, '#name' do
+  subject { object.name }
+
+  let(:object)        { klass.new(name, handler, failure_chain) }
+  let(:klass)         { Class.new { include Processor::Fallible } }
+  let(:name)          { mock }
+  let(:handler)       { mock }
+  let(:failure_chain) { mock }
+
+  it { should be(name) }
+end

data/spec/unit/substation/processor/fallible/with_failure_chain_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Fallible, '#with_failure_chain' do
+  subject { object.with_failure_chain(chain) }
+
+  let(:object)        { klass.new(name, handler, failure_chain) }
+  let(:klass)         { Class.new { include Processor::Fallible } }
+  let(:name)          { mock }
+  let(:handler)       { mock }
+  let(:failure_chain) { mock }
+  let(:chain)         { mock }
+
+  let(:expected) { klass.new(name, handler, chain) }
+
+  it { should eql(expected) }
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Incoming, '#result' do
+
+  subject { object.result(response) }
+
+  let(:object) {
+    Class.new {
+      include Substation::Processor::Incoming
+    }.new(processor_name, handler, failure_chain)
+  }
+
+  let(:processor_name) { mock }
+  let(:response)       { Response::Success.new(request, input) }
+  let(:request)        { Request.new(action_name, env, input) }
+  let(:action_name)    { mock }
+  let(:env)            { mock }
+  let(:input)          { mock }
+  let(:failure_chain)  { mock }
+  let(:handler)        { mock }
+
+  it { should eql(request) }
+end

data/spec/unit/substation/processor/outgoing/call_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Outgoing, '#call' do
+
+  subject { object.call(request) }
+
+  let(:object) {
+    Class.new {
+      include Substation::Processor::Outgoing
+      def call(request)
+        response = request.success(request.input)
+        respond_with(response, :altered)
+      end
+    }.new(processor_name, handler)
+  }
+
+  let(:processor_name) { mock }
+  let(:response)       { Response::Success.new(request, :altered) }
+  let(:request)        { Request.new(action_name, env, input) }
+  let(:action_name)    { mock }
+  let(:env)            { mock }
+  let(:input)          { mock }
+  let(:handler)        { mock }
+
+  it { should eql(response) }
+end

data/spec/unit/substation/processor/outgoing/name_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Outgoing, '#name' do
+  subject { object.name }
+
+  let(:object)  { klass.new(name, handler) }
+  let(:klass)   { Class.new { include Processor::Outgoing } }
+  let(:name)    { mock }
+  let(:handler) { mock }
+
+  it { should be(name) }
+end

data/spec/unit/substation/processor/outgoing/success_predicate_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Outgoing, '#success?' do
+  subject { object.success?(response) }
+
+  let(:object)   { klass.new(name, handler) }
+  let(:klass)    { Class.new { include Processor::Outgoing } }
+  let(:name)     { mock }
+  let(:handler)  { mock }
+  let(:response) { mock }
+
+  it { should be(true) }
+end

data/spec/unit/substation/{chain/outgoing → processor}/result_spec.rb

@@ -2,18 +2,19 @@
 
 require 'spec_helper'
 
-describe Chain::Outgoing, '#result' do
+describe Processor, '#result' do
 
   subject { object.result(response) }
 
   let(:object) {
     Class.new {
-      include Substation::Chain::Outgoing
+      include Substation::Processor
     }.new
   }
 
   let(:response) { Response::Success.new(request, input) }
-  let(:request)  { Request.new(env, input) }
+  let(:request)  { Request.new(name, env, input) }
+  let(:name)     { mock }
   let(:env)      { mock }
   let(:input)    { mock }
 

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor, '#success?' do
+  subject { object.success?(response) }
+
+  let(:object)  { klass.new }
+  let(:klass)   { Class.new { include Processor } }
+
+  context 'with a successful response' do
+    let(:response) { mock(:success? => true) }
+
+    it { should be(true) }
+  end
+
+  context 'with a failure response' do
+    let(:response) { mock(:success? => false) }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Transformer, '#call' do
+  subject { object.call(response) }
+
+  let(:object)         { described_class.new(processor_name, Spec::Transformer) }
+  let(:processor_name) { mock }
+  let(:response)       { Response::Success.new(request, output) }
+  let(:request)        { Request.new(action_name, env, input) }
+  let(:action_name)    { mock }
+  let(:env)            { mock }
+  let(:input)          { mock }
+  let(:output)         { mock }
+
+  let(:transformed) { Response::Success.new(request, data) }
+  let(:data)        { Spec::Transformer.call(response) }
+
+  it { should eql(transformed) }
+end

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

@@ -5,15 +5,17 @@ require 'spec_helper'
 describe Processor::Wrapper, '#call' do
   subject { object.call(response) }
 
-  let(:object)   { described_class.new(Spec::Handler::Wrapper::Presenter) }
-  let(:response) { Response::Success.new(request, output) }
-  let(:request)  { Request.new(env, input) }
-  let(:env)      { mock }
-  let(:input)    { mock }
-  let(:output)   { mock }
+  let(:object)         { described_class.new(processor_name, Spec::Presenter) }
+  let(:processor_name) { mock }
+  let(:response)       { Response::Success.new(request, output) }
+  let(:request)        { Request.new(action_name, env, input) }
+  let(:action_name)    { mock }
+  let(:env)            { mock }
+  let(:input)          { mock }
+  let(:output)         { mock }
 
   let(:wrapped) { Response::Success.new(request, data) }
-  let(:data)    { Spec::Handler::Wrapper::Presenter.new(output) }
+  let(:data)    { Spec::Presenter.new(output) }
 
   it { should eql(wrapped) }
 end