substation 0.0.10.beta2 → 0.0.10

data/spec/demo/web/sanitizer/person.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+class Demo
+  module Web
+    module Sanitizer
+
+      NEW_PERSON = Ducktrap.build do
+        primitive(Hash)
+        hash_transform do
+          fetch_key('name') do
+            primitive(String)
+            dump_key(:name)
+          end
+        end
+        add(ID_TRAP)
+        anima_load(Domain::DTO::Person)
+      end
+    end
+  end
+end

data/spec/demo/web/views.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+class Demo
+  module Web
+
+    module Views
+
+      module Layout
+        def page_title
+          'substation demo'
+        end
+      end
+
+      class Person < Presenter
+        include Layout
+      end
+
+      class SanitizationError
+        include Concord::Public.new(:error)
+        include Layout
+      end
+
+      class InternalError
+        include Concord::Public.new(:data)
+      end
+    end
+  end
+end

data/spec/integration/demo/core_spec.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+require 'demo/core'
+
+describe 'a typical substation application' do
+  subject { object.call(name, input) }
+
+  let(:object) { Demo::Core::APP }
+
+  include_context 'demo application'
+  include_context 'with registered chains'
+
+  let(:input) { Demo::Core::Input::Incomplete.new(session_data, person) }
+
+  context 'with valid input' do
+    let(:person_name)     { 'John' }
+    let(:account_id)      { authorized_id }
+    let(:processed_input) { accepted_input }
+    let(:response)        { Substation::Response::Success.new(processed_request, person) }
+
+    it_behaves_like 'an action invocation' do
+      let(:action_response) { response }
+      let(:success_status) { true }
+    end
+  end
+
+  context 'with an input that produces an application error' do
+    let(:person_name)     { 'error' }
+    let(:account_id)      { authorized_id }
+    let(:processed_input) { accepted_input }
+    let(:error)           { Demo::Core::Error::ApplicationError.new(person) }
+    let(:response)        { error_response }
+
+    it_behaves_like 'an action invocation' do
+      let(:action_response) { Substation::Response::Failure.new(processed_request, person) }
+      let(:success_status)  { false }
+    end
+  end
+
+  context 'with an input that raises an exception while processing' do
+    let(:person_name)     { 'exception' }
+    let(:account_id)      { authorized_id }
+    let(:processed_input) { accepted_input }
+    let(:failure_data)    { Substation::Response::Exception::Output.new(processed_input, RuntimeError.new) }
+    let(:error)           { Demo::Core::Error::InternalError.new(failure_data) }
+    let(:response)        { exception_response }
+
+    it_behaves_like 'no action invocation'
+  end
+
+  context 'with invalid input' do
+    let(:person_name)      { 'X' }
+    let(:account_id)       { authorized_id }
+    let(:processed_input)  { incomplete_input }
+    let(:error)            { Demo::Core::Error::ValidationError.new(invalid_input) }
+    let(:invalid_input)    { Demo::Core::Input::Incomplete.new(session_data, validation_error) }
+    let(:validation_error) { Demo::Domain::DTO::NEW_PERSON_VALIDATOR.call(person).output }
+    let(:response)         { error_response }
+
+    it_behaves_like 'no action invocation'
+  end
+
+  context 'with malformed input' do
+    let(:person)          { :foo }
+    let(:account_id)      { authorized_id }
+    let(:processed_input) { incomplete_input }
+    let(:failure_data)    { Substation::Response::Exception::Output.new(processed_input, RuntimeError.new) }
+    let(:error)           { Demo::Core::Error::InternalError.new(failure_data) }
+    let(:response)        { exception_response }
+
+    pending 'the response is returned is actually correct, but somehow #eql? fails' do
+      it_behaves_like 'no action invocation'
+    end
+  end
+
+  context 'with input from an unknown user' do
+    let(:person_name)     { 'unknown' }
+    let(:account_id)      { unknown_id }
+    let(:processed_input) { incomplete_input }
+    let(:error)           { Demo::Core::Error::AuthenticationError.new(processed_input) }
+    let(:response)        { error_response }
+
+    it_behaves_like 'no action invocation'
+  end
+
+  context 'with input from an unauthorized user' do
+    let(:person_name)     { 'forbidden' }
+    let(:account_id)      { unauthorized_id }
+    let(:processed_input) { incomplete_input }
+    let(:error)           { Demo::Core::Error::AuthorizationError.new(processed_input) }
+    let(:response)        { error_response }
+
+    it_behaves_like 'no action invocation'
+  end
+end

data/spec/integration/demo/web_spec.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+require 'demo/web'
+
+describe 'a typical substation application' do
+  subject { object.call(name, input) }
+
+  let(:object) { Demo::Web::HTML::APP }
+
+  include_context 'demo application'
+  include_context 'with registered chains'
+
+  let(:input) {
+    {
+      'session' => MultiJson.dump(session_data),
+      'data'    => MultiJson.dump(data)
+    }
+  }
+
+  let(:data)                        { { 'name' => person_name } }
+  let(:rendered_error_response)     { Substation::Response::Failure.new(processed_request, rendered) }
+  let(:rendered_exception_response) { Substation::Response::Exception.new(processed_request, rendered) }
+
+  context 'with valid input' do
+    let(:person_name)     { 'John' }
+    let(:account_id)      { authorized_id }
+    let(:processed_input) { accepted_input }
+    let(:presenter)       { Demo::Web::Presenter::Person.new(person) }
+    let(:view)            { Demo::Web::Views::Person.new(presenter) }
+    let(:response)        { Substation::Response::Success.new(processed_request, view) }
+
+    it_behaves_like 'an action invocation' do
+      let(:action_response) { Substation::Response::Success.new(processed_request, person) }
+      let(:success_status) { true }
+    end
+  end
+
+  context 'with an input that produces an application error' do
+    let(:person_name)     { 'error' }
+    let(:account_id)      { authorized_id }
+    let(:processed_input) { accepted_input }
+    let(:error)           { Demo::Core::Error::ApplicationError.new(person) }
+    let(:rendered)        { Demo::Web::Renderer::ApplicationError.call(error_response) }
+    let(:response)        { rendered_error_response }
+
+    it_behaves_like 'an action invocation' do
+      let(:action_response) { Substation::Response::Failure.new(processed_request, person) }
+      let(:success_status)  { false }
+    end
+  end
+
+  context 'with an input that raises an exception while processing' do
+    let(:person_name)     { 'exception' }
+    let(:account_id)      { authorized_id }
+    let(:processed_input) { accepted_input }
+    let(:failure_data)    { Substation::Response::Exception::Output.new(processed_input, RuntimeError.new) }
+    let(:error)           { Demo::Core::Error::InternalError.new(failure_data) }
+    let(:view)            { Demo::Web::Views::InternalError.new(error) }
+    let(:error_data)      { view }
+    let(:rendered)        { Demo::Web::Renderer::InternalError.call(error_response) }
+    let(:response)        { rendered_exception_response }
+
+    it_behaves_like 'no action invocation'
+  end
+
+  context 'with invalid input' do
+    let(:person_name)     { 'X' }
+    let(:account_id)      { authorized_id }
+    let(:processed_input) { incomplete_input }
+    let(:error)           { Demo::Core::Error::ValidationError.new(person) }
+    let(:rendered)        { Demo::Web::Renderer::ValidationError.call(error_response) }
+    let(:response)        { rendered_error_response }
+
+    it_behaves_like 'no action invocation'
+  end
+
+  context 'with malformed input' do
+    let(:data)            { { 'malformed' => 'input' } }
+    let(:account_id)      { authorized_id }
+    let(:processed_input) { incomplete_input }
+    let(:incomplete_data) { data }
+    let(:error)           { Demo::Web::Error::SanitizationError.new(processed_input) }
+    let(:view)            { Demo::Web::Views::SanitizationError.new(error) }
+    let(:error_data)      { view }
+    let(:rendered)        { Demo::Web::Renderer::SanitizationError.call(error_response) }
+    let(:response)        { rendered_error_response }
+
+    it_behaves_like 'no action invocation'
+  end
+
+  context 'with input from an unknown user' do
+    let(:person_name)     { 'unknown' }
+    let(:account_id)      { unknown_id }
+    let(:processed_input) { incomplete_input }
+    let(:error)           { Demo::Core::Error::AuthenticationError.new(processed_input) }
+    let(:rendered)        { Demo::Web::Renderer::AuthenticationError.call(error_response) }
+    let(:response)        { rendered_error_response }
+
+    it_behaves_like 'no action invocation'
+  end
+
+  context 'with input from an unauthorized user' do
+    let(:person_name)     { 'forbidden' }
+    let(:account_id)      { unauthorized_id }
+    let(:processed_input) { incomplete_input }
+    let(:error)           { Demo::Core::Error::AuthorizationError.new(processed_input) }
+    let(:rendered)        { Demo::Web::Renderer::AuthorizationError.call(error_response) }
+    let(:response)        { rendered_error_response }
+
+    it_behaves_like 'no action invocation'
+  end
+end

data/spec/shared/context/integration/demo.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+shared_context 'demo application' do
+  let(:request)           { Substation::Request.new(name, env, input) }
+  let(:name)              { :create_person }
+  let(:env)               { Demo::APP_ENV }
+
+  let(:session_data)      { { 'account_id' => account_id } }
+
+  let(:authorized_id)     {  1 }
+  let(:unauthorized_id)   {  2 }
+  let(:unknown_id)        { -1 }
+
+  let(:processed_request) { Substation::Request.new(name, env, processed_input) }
+  let(:actor)             { Demo::Domain::Actor.coerce(session_data, acting_person) }
+  let(:acting_person)     { Demo::Domain::DTO::Person.new(:id => account_id, :name => 'Jane') }
+
+  let(:accepted_input)    { Demo::Core::Input::Accepted.new(actor, person) }
+  let(:incomplete_input)  { Demo::Core::Input::Incomplete.new(session_data, incomplete_data) }
+  let(:incomplete_data)   { person }
+
+  let(:person)            { Demo::Domain::DTO::Person.new(:id => nil, :name => person_name) }
+
+  let(:error_response)     { Substation::Response::Failure.new(processed_request, error_data) }
+  let(:exception_response) { Substation::Response::Exception.new(processed_request, error_data) }
+  let(:error_data)         { error }
+
+end
+
+shared_context 'with registered chains' do
+  let(:input)      { mock }
+  let(:account_id) { authorized_id }
+end

data/spec/shared/context/unit/chain.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+shared_context 'Chain::DSL#initialize' do
+  let(:chain_dsl)      { Chain::DSL.build(registry, definition) }
+  let(:registry)       { Environment::DSL.registry(&env_block) }
+  let(:env_block)      { ->(_) { register(:test, Spec::Processor) } }
+  let(:processor_name) { :test }
+
+  let(:definition)     { Chain::Definition.new(chain_name, processors) }
+  let(:chain_name)     { double('chain_name') }
+  let(:processors)     { [processor] }
+  let(:processor)      { double('processor', :name => :processor) }
+end

data/spec/shared/context/unit/processor.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+shared_context 'Processor::Executor#initialize' do
+  let(:executor)        { Processor::Executor.new(decomposer, composer) }
+  let(:decomposer)      { double('decomposer') }
+  let(:composer)        { double('composer') }
+  let(:decomposed)      { double('decomposed') }
+  let(:composed)        { double('composed') }
+  let(:handler_result)  { double('handler_result') }
+  let(:handler_output)  { double('handler_output') }
+  let(:handler_success) { true }
+
+  before do
+    allow(handler_result).to receive(:success?).with(no_args).and_return(handler_success)
+    allow(handler_result).to receive(:output).with(no_args).and_return(handler_output)
+  end
+end
+
+shared_context 'Processor::Config#initialize' do
+  include_context 'Processor::Executor#initialize'
+
+  let(:processor_config) { Processor::Config.new(executor, failure_chain, observers) }
+  let(:failure_chain)    { double('failure_chain') }
+  let(:observers)        { double('observers') }
+  let(:observer)         { double('observer') }
+end
+
+shared_context 'Processor#initialize' do
+  include_context 'Processor::Config#initialize'
+
+  let(:object)           { klass.new(processor_name, handler, processor_config) }
+  let(:processor_name)   { double('name') }
+  let(:handler)          { double('handler') }
+  let(:failure_response) { double('failure_response') }
+end
+
+shared_context 'Processor::Call' do
+
+  include_context 'Request#initialize'
+  include_context 'Processor#initialize'
+
+  let(:response)      { Response::Success.new(request, original_data) }
+  let(:original_data) { double('original_data') }
+
+  let(:expected)      { Response::Success.new(request, expected_data) }
+  let(:expected_data) { composed }
+end
+
+shared_context 'Processor::Builder#initialize' do
+  include_context 'Processor::Executor#initialize'
+
+  let(:processor_builder) {
+    Processor::Builder.new(processor_name, processor_klass, executor)
+  }
+
+  let(:processor_name)  { :test }
+  let(:processor_klass) { Spec::Processor }
+end

data/spec/shared/context/unit/request.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+shared_context 'Request#initialize' do
+  let(:request) { Request.new(name, env, input) }
+  let(:name)    { double }
+  let(:env)     { double }
+  let(:input)   { double }
+end

data/spec/shared/examples/integration/demo.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+shared_examples_for 'all invocations' do
+  it { should eql(response) }
+
+  it 'indicates success via #success?' do
+    expect(subject.success?).to be(success_status)
+  end
+
+  it 'provides the processed input in Response#input' do
+    expect(subject.input).to eql(processed_input)
+  end
+end
+
+shared_examples_for 'an action invocation' do
+  it_behaves_like 'all invocations'
+
+  it 'notifies all observers' do
+    expect(Demo::Core::Observers::LOG_EVENT).to receive(:call).with(action_response).ordered
+    expect(Demo::Core::Observers::SEND_EMAIL).to receive(:call).with(action_response).ordered
+    subject
+  end
+end
+
+shared_examples_for 'no action invocation' do
+  let(:success_status) { false }
+
+  it_behaves_like 'all invocations'
+
+  it 'does not notify any observers' do
+    expect(Demo::Core::Observers::LOG_EVENT).to_not receive(:call)
+    expect(Demo::Core::Observers::SEND_EMAIL).to_not receive(:call)
+    subject
+  end
+end

data/spec/shared/examples/unit/processor.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+shared_examples_for 'Processor::Call::Outgoing#call' do
+  subject { object.call(response) }
+
+  include_context 'Processor::Call'
+
+  before do
+    expect(decomposer).to receive(:call).with(response).and_return(decomposed)
+    expect(handler_result).to_not receive(:success?)
+    expect(handler_result).to_not receive(:output)
+    expect(composer).to receive(:call).with(response, handler_result).and_return(composed)
+  end
+
+  it { should eql(expected) }
+end
+
+shared_examples_for 'Processor::Call::Incoming#call' do
+  subject { object.call(request) }
+
+  include_context 'Processor::Call'
+
+  before do
+    expect(decomposer).to receive(:call).with(request).and_return(decomposed)
+    expect(handler_result).to_not receive(:success?)
+    expect(handler_result).to_not receive(:output)
+    expect(composer).to receive(:call).with(request, handler_result).and_return(composed)
+  end
+
+  it { should eql(expected) }
+end
+
+shared_examples_for 'Processor::Evaluator#call' do
+  subject { object.call(request) }
+
+  include_context 'Processor::Call'
+
+  context 'with a successful handler' do
+    let(:handler_success) { true }
+    let(:response)        { Response::Success.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(handler_result).to receive(:output)
+      expect(composer).to receive(:call).with(request, handler_output).and_return(composed)
+    end
+
+    it { should eql(expected) }
+  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(handler_result).to receive(:output)
+      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