substation 0.0.8 → 0.0.9

data/lib/substation/utils.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Substation
 
   # A collection of utility methods
@@ -12,7 +14,7 @@ module Substation
     #
     # @api private
     def self.const_get(name)
-      list = name.to_s.split("::")
+      list = name.to_s.split('::')
       list.shift if list.first.empty?
       obj = Object
       list.each do |const|

data/lib/substation/version.rb

@@ -1,4 +1,6 @@
+# encoding: utf-8
+
 module Substation
   # Gem version
-  VERSION = '0.0.8'.freeze
+  VERSION = '0.0.9'.freeze
 end

data/spec/integration/substation/dispatcher/call_spec.rb

@@ -181,8 +181,8 @@ module App
   end # module Actions
 
   module Observers
-    LogEvent  = Proc.new { |response| response }
-    SendEmail = Proc.new { |response| response }
+    LOG_EVENT  = ->(response) { response }
+    SEND_EMAIL = ->(response) { response }
   end
 
   DB = Database.new({
@@ -198,8 +198,8 @@ module App
     :create_person => {
       :action   => Actions::CreatePerson,
       :observer => [
-        Observers::LogEvent,
-        Observers::SendEmail
+        Observers::LOG_EVENT,
+        Observers::SEND_EMAIL
       ]
     }
   }
@@ -213,11 +213,11 @@ end
 
 describe App::APP, '#call' do
 
-  context "when dispatching an action" do
+  context 'when dispatching an action' do
     subject { object.call(action, input) }
 
     let(:object)   { described_class }
-    let(:request)  { Substation::Request.new(env, input) }
+    let(:request)  { Substation::Request.new(action, env, input) }
     let(:env)      { App::Environment.new(storage) }
     let(:storage)  { App::Storage.new(App::DB) }
     let(:response) { Substation::Response::Success.new(request, output) }
@@ -225,7 +225,7 @@ describe App::APP, '#call' do
     let(:john) { App::Models::Person.new(:id => 1, :name => 'John') }
     let(:jane) { App::Models::Person.new(:id => 2, :name => 'Jane') }
 
-    context "with no input data" do
+    context 'with no input data' do
       let(:action)  { :list_people }
       let(:input)   { nil }
       let(:output)  { [ john ] }
@@ -233,8 +233,8 @@ describe App::APP, '#call' do
       it { should eql(response) }
     end
 
-    context "with input data" do
-      context "and no observer" do
+    context 'with input data' do
+      context 'and no observer' do
         let(:action) { :load_person }
         let(:input)  { 1 }
         let(:output) { john }
@@ -242,14 +242,14 @@ describe App::APP, '#call' do
         it { should eq(response) }
       end
 
-      context "and observers" do
+      context 'and observers' do
         let(:action)   { :create_person }
         let(:input)    { jane }
         let(:output)   { [ john, jane ] }
 
         before do
-          App::Observers::LogEvent.should_receive(:call).with(response).ordered
-          App::Observers::SendEmail.should_receive(:call).with(response).ordered
+          App::Observers::LOG_EVENT.should_receive(:call).with(response).ordered
+          App::Observers::SEND_EMAIL.should_receive(:call).with(response).ordered
         end
 
         it { should eql(response) }

data/spec/spec_helper.rb

@@ -1,7 +1,28 @@
+# encoding: utf-8
+
 require 'devtools/spec_helper'
 
 require 'concord' # makes spec setup easier
 
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name     'spec:unit'
+    add_filter       'config'
+    add_filter       'spec'
+    minimum_coverage 100
+  end
+end
+
+require 'substation'
+
 module Spec
 
   def self.response_data
@@ -28,7 +49,18 @@ module Spec
   end
 
   class Processor
-    include Concord.new(:handler)
+    include Substation::Processor::Fallible
+    attr_reader :name
+  end
+
+  class Presenter
+    include Concord.new(:data)
+  end
+
+  class Transformer
+    def self.call(response)
+      :transformed
+    end
   end
 
   module Handler
@@ -51,6 +83,10 @@ module Spec
         end
       end
 
+      def self.call(data)
+        new.call(data)
+      end
+
       def call(data)
         if data == :success
           Result::Success.new(data)
@@ -66,43 +102,14 @@ module Spec
       end
     end
 
-    class Wrapper
-      class Presenter
-        include Concord.new(:data)
-      end
-
-      include Concord.new(:data)
-
-      def call(data)
-        Presenter.new(data)
-      end
-    end
   end
 
   FAKE_HANDLER   = Object.new
-  FAKE_PROCESSOR = Processor.new(FAKE_HANDLER)
-
-end
-
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-  require 'coveralls'
+  FAKE_ENV       = Object.new
+  FAKE_PROCESSOR = Processor.new(:test, FAKE_HANDLER, [])
 
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-
-  SimpleCov.start do
-    command_name     'spec:unit'
-    add_filter       'config'
-    add_filter       'spec'
-    minimum_coverage 100
-  end
 end
 
-require 'substation'
-
 include Substation
 
 RSpec.configure do |config|

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

@@ -6,52 +6,228 @@ describe Chain, '#call' do
 
   subject { object.call(request) }
 
-  let(:object)   { described_class.new(handlers) }
-  let(:handlers) { [ handler_1, handler_2 ] }
-  let(:request)  { Request.new(env, input) }
-  let(:env)      { mock }
-  let(:input)    { mock }
-
-  let(:handler_2) {
-    Class.new {
-      include Substation::Chain::Outgoing
-      def call(request)
-        request.success(request.input)
-      end
-    }.new
-  }
+  let(:object)          { described_class.new(processors, exception_chain) }
+  let(:exception_chain) { mock(:call => response) }
+  let(:processors)      { [ processor_1, processor_2, processor_3 ] }
+  let(:request)         { Request.new(name, env, input) }
+  let(:name)            { mock }
+  let(:env)             { mock }
+  let(:input)           { mock }
+
+  let(:failure_chain) { mock }
+  let(:handler)       { mock }
+
+  let(:processor_1_name) { mock }
+  let(:processor_2_name) { mock }
+  let(:processor_3_name) { mock }
 
-  context "when all handlers are successful" do
-    let(:handler_1) {
+  context 'when all processors are successful' do
+    let(:processor_1) {
       Class.new {
-        include Substation::Chain::Incoming
+        include Substation::Processor::Incoming
         def call(request)
-          request.success(request.input)
+          request.success(:success_1)
+        end
+      }.new(processor_1_name, handler, failure_chain)
+    }
+
+    let(:processor_2) {
+      Class.new {
+        include Substation::Processor::Pivot
+        def call(request)
+          request.success(:success_2)
+        end
+      }.new(processor_2_name, handler, failure_chain)
+    }
+
+    let(:processor_3) {
+      Class.new {
+        include Substation::Processor::Outgoing
+        def call(response)
+          respond_with(response, :success_3)
         end
-      }.new
+      }.new(processor_3_name, handler)
     }
 
-    let(:response) { Response::Success.new(request, request.input) }
+    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 intermediate handler is not successful" do
-    let(:handler_1) {
+  context 'when an incoming processor is not successful' do
+
+    let(:processor_2) {
       Class.new {
-        include Substation::Chain::Incoming
+        include Substation::Processor::Pivot
         def call(request)
-          request.error(request.input)
+          request.success(:success_1)
         end
-      }.new
+      }.new(processor_2_name, handler, failure_chain)
     }
 
-    let(:response) { Response::Failure.new(request, request.input) }
+    let(:processor_3) {
+      Class.new {
+        include Substation::Processor::Outgoing
+        def call(response)
+          respond_with(response, :success_3)
+        end
+      }.new(processor_3_name, handler)
+    }
+
+    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, failure_chain)
+      }
 
-    before do
-      handler_2.should_not_receive(:call)
+      let(:response) { Response::Failure.new(request, :error_1) }
+
+      it { should eql(response) }
     end
 
-    it { should eql(response) }
+    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, failure_chain)
+      }
+
+      let(:response) { Response::Failure.new(request, data) }
+      let(:data)     { Chain::FailureData.new(request, 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
+        exception_chain.should_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, failure_chain)
+    }
+
+    let(:processor_3) {
+      Class.new {
+        include Substation::Processor::Outgoing
+        def call(response)
+          response
+        end
+      }.new(processor_3_name, handler)
+    }
+
+    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, failure_chain)
+      }
+
+      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, failure_chain)
+      }
+
+      let(:response)        { Response::Failure.new(request, data) }
+      let(:data)            { Chain::FailureData.new(current_request, 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
+        exception_chain.should_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, failure_chain)
+    }
+
+    let(:processor_2) {
+      Class.new {
+        include Substation::Processor::Pivot
+        def call(response)
+          response.success(:success_2)
+        end
+      }.new(processor_2_name, handler, failure_chain)
+    }
+
+    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)
+      }
+
+      let(:response)         { Response::Failure.new(request, data) }
+      let(:data)             { Chain::FailureData.new(current_response, 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
+        exception_chain.should_receive(:call).with(response)
+        subject
+      end
+    end
   end
 end