substation 0.0.9 → 0.0.10.beta2

data/lib/substation/request.rb

@@ -1,20 +1,11 @@
-# encoding: utf-8
-
 module Substation
 
   # Encapsulates the application environment and an input model instance
   class Request
 
-    include Concord.new(:name, :env, :input)
+    include Concord.new(:env, :input)
     include Adamantium::Flat
 
-    # The name of the request
-    #
-    # @return [Symbol]
-    #
-    # @api private
-    attr_reader :name
-
     # The application environment
     #
     # @example

data/lib/substation/response.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Substation
 
   # Base class for action responses
@@ -131,15 +129,6 @@ module Substation
     # @api public
     abstract_method :success?
 
-    # Return a {Request} instance built upon this response
-    #
-    # @return [Request]
-    #
-    # @api private
-    def to_request
-      Request.new(request.name, env, output)
-    end
-
     # An errorneous {Response}
     class Failure < self
 

data/lib/substation/utils.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Substation
 
   # A collection of utility methods
@@ -14,7 +12,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,6 +1,4 @@
-# encoding: utf-8
-
 module Substation
   # Gem version
-  VERSION = '0.0.9'.freeze
+  VERSION = '0.0.10.beta2'.freeze
 end

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

@@ -181,8 +181,8 @@ module App
   end # module Actions
 
   module Observers
-    LOG_EVENT  = ->(response) { response }
-    SEND_EMAIL = ->(response) { response }
+    LogEvent  = Proc.new { |response| response }
+    SendEmail = Proc.new { |response| response }
   end
 
   DB = Database.new({
@@ -198,8 +198,8 @@ module App
     :create_person => {
       :action   => Actions::CreatePerson,
       :observer => [
-        Observers::LOG_EVENT,
-        Observers::SEND_EMAIL
+        Observers::LogEvent,
+        Observers::SendEmail
       ]
     }
   }
@@ -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(action, env, input) }
+    let(:request)  { Substation::Request.new(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::LOG_EVENT.should_receive(:call).with(response).ordered
-          App::Observers::SEND_EMAIL.should_receive(:call).with(response).ordered
+          App::Observers::LogEvent.should_receive(:call).with(response).ordered
+          App::Observers::SendEmail.should_receive(:call).with(response).ordered
         end
 
         it { should eql(response) }

data/spec/spec_helper.rb

@@ -1,28 +1,7 @@
-# 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
@@ -49,20 +28,13 @@ module Spec
   end
 
   class Processor
-    include Substation::Processor::Fallible
-    attr_reader :name
+    include Concord::Public.new(:env, :handler)
   end
 
   class Presenter
     include Concord.new(:data)
   end
 
-  class Transformer
-    def self.call(response)
-      :transformed
-    end
-  end
-
   module Handler
 
     class Evaluator
@@ -106,10 +78,29 @@ module Spec
 
   FAKE_HANDLER   = Object.new
   FAKE_ENV       = Object.new
-  FAKE_PROCESSOR = Processor.new(:test, FAKE_HANDLER, [])
+  FAKE_PROCESSOR = Processor.new(FAKE_ENV, FAKE_HANDLER)
 
 end
 
+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'
+
 include Substation
 
 RSpec.configure do |config|

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

@@ -6,228 +6,58 @@ describe Chain, '#call' do
 
   subject { object.call(request) }
 
-  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 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, 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(processor_3_name, handler)
-    }
-
-    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, failure_chain)
-    }
-
-    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)
-      }
-
-      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, 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')
+  let(:object)   { described_class.new(handlers) }
+  let(:handlers) { [ handler_1, handler_2 ] }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
+
+  let(:handler_2) {
+    Class.new {
+      include Substation::Chain::Outgoing
+      def call(request)
+        request.success(request.input)
       end
+    }.new
+  }
 
-      it 'calls the failure chain' do
-        exception_chain.should_receive(:call).with(response)
-        subject
-      end
-    end
-  end
+  let(:response) { response_class.new(request, request.input) }
 
-  context 'when the pivot processor is not successful' do
-    let(:processor_1) {
+  context "when all handlers are successful" do
+    let(:handler_1) {
       Class.new {
-        include Substation::Processor::Incoming
+        include Substation::Chain::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
+          request.success(request.input)
         end
-      }.new(processor_3_name, handler)
+      }.new
     }
 
-    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_class) { Response::Success }
 
-      let(:response)        { Response::Failure.new(current_request, :error_2) }
-      let(:current_request) { Request.new(name, env, :success_1) }
-
-      it { should eql(response) }
+    before do
+      handler_2.should_receive(:call).with(request).and_return(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
+    it { should eql(response) }
   end
 
-  context 'when an outgoing processor is not successful' do
-    let(:processor_1) {
+  context "when an intermediate handler is not successful" do
+    let(:handler_1) {
       Class.new {
-        include Substation::Processor::Incoming
+        include Substation::Chain::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)
+          request.error(request.input)
         end
-      }.new(processor_2_name, handler, failure_chain)
+      }.new
     }
 
     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
+    before do
+      handler_2.should_not_receive(:call)
     end
+
+    it { should eql(response) }
   end
 end