substation 0.0.1

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'substation'
+require 'devtools/spec_helper'
+
+module Spec
+
+  def self.response_data
+    :data
+  end
+
+  class Observer
+    def self.call(response)
+    end
+  end
+
+  class Action
+    class Success
+      def self.call(request)
+        request.success(Spec.response_data)
+      end
+    end
+
+    class Failure
+      def self.call(request)
+        request.error(Spec.response_data)
+      end
+    end
+  end
+
+end
+
+include Substation
+
+RSpec.configure do |config|
+end

data/spec/unit/substation/dispatcher/action/call_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Dispatcher::Action, '#call' do
+
+  subject { object.call(request) }
+
+  let(:object)   { described_class.new(klass, observer) }
+  let(:klass)    { mock }
+  let(:observer) { mock }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+  let(:response) { mock }
+
+  before do
+    klass.should_receive(:call).with(request).and_return(response)
+    observer.should_receive(:call).with(response)
+  end
+
+  it { should eql(response) }
+end

data/spec/unit/substation/dispatcher/action/class_methods/coerce_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Dispatcher::Action, '.coerce' do
+
+  subject { described_class.coerce(config) }
+
+  let(:action)  { Spec::Action::Success }
+  let(:coerced) { Dispatcher::Action.new(action, observer) }
+
+  context "when coercion is possible" do
+
+    let(:config) {{
+        :action   => action,
+        :observer => observer_value
+    }}
+
+    before do
+      Observer.should_receive(:coerce).with(observer_value).and_return(observer)
+      Utils.should_receive(:coerce_callable).with(action).and_return(action)
+    end
+
+    context 'with an action and an observer' do
+      let(:observer_value) { observer }
+      let(:observer)       { Spec::Observer }
+
+      it { should eql(coerced) }
+    end
+
+    context 'with an action and no observer' do
+      let(:observer_value) { nil }
+      let(:observer)       { Observer::NULL }
+
+      it { should eql(coerced) }
+    end
+  end
+
+  context 'with no action' do
+    let(:config) { {} }
+
+    specify {
+      expect { subject }.to raise_error(described_class::MissingHandlerError)
+    }
+  end
+end

data/spec/unit/substation/dispatcher/action_names_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Dispatcher, '#action_names' do
+
+  subject { object.action_names }
+
+  let(:object) { described_class.new(config) }
+  let(:config) { { :test => { :action => Spec::Action::Success } } }
+
+  it { should eql(Set[ :test ]) }
+end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Dispatcher, '#call' do
+
+  subject { object.call(action_name, input, env) }
+
+  let(:object)  { described_class.coerce(config)                        }
+  let(:config)  { { 'test' => { 'action' => 'Spec::Action::Success' } } }
+  let(:request) { Request.new(env, input) }
+  let(:input)   { mock }
+  let(:env)     { mock }
+
+  let(:expected_response) do
+    Spec::Action::Success.call(request)
+  end
+
+  context 'when the action is registered' do
+    let(:action_name) { :test }
+
+    context 'without callbacks' do
+      it { should eql(expected_response) }
+    end
+
+    context 'with observers' do
+      let(:config) {
+        config = super()
+        config['test']['observer'] = 'Spec::Observer'
+        config
+      }
+
+      it 'should call callback with response' do
+        Spec::Observer.should_receive(:call).with(expected_response)
+        should eql(expected_response)
+      end
+    end
+  end
+
+  context 'when the action is not registered' do
+    let(:action_name) { :unknown }
+
+    specify do
+      expect { subject }.to raise_error(described_class::UnknownActionError)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Dispatcher, '.coerce' do
+
+  subject { described_class.coerce(config) }
+
+  let(:config) {{
+    'test' => { 'action' => 'Spec::Action::Success' }
+  }}
+
+  let(:coerced) {{
+    :test => described_class::Action.coerce(:action => 'Spec::Action::Success')
+  }}
+
+  it { should eql(described_class.new(coerced)) }
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Observer::Chain, '#call' do
+  subject { object.call(response) }
+
+  let(:object) { Observer::Chain.new(observers) }
+
+  let(:response)   { mock('Response') }
+  let(:observer_a) { mock('Observer A') }
+  let(:observer_b) { mock('Observer B') }
+
+  let(:observers) { [observer_a, observer_b] }
+
+  it_should_behave_like 'a command method'
+
+  before do
+    observer_a.stub(:call)
+    observer_b.stub(:call)
+  end
+
+  it 'should call observers' do
+    observer_a.should_receive(:call).with(response)
+    observer_b.should_receive(:call).with(response)
+    subject
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Observer, '.coerce' do
+
+  subject { object.coerce(input) }
+
+  let(:object) { described_class }
+
+  context 'with nil input' do
+    let(:input) { nil }
+
+    it { should be(described_class::NULL) }
+  end
+
+  context 'with array input' do
+    let(:input) { ['Spec::Observer', nil] }
+
+    let(:observers) { [Spec::Observer, described_class::NULL] }
+
+    it { should eql(described_class::Chain.new(observers)) }
+  end
+
+  context 'with other input' do
+    let(:input)   { mock }
+    let(:coerced) { mock }
+
+    before do
+      Utils.should_receive(:coerce_callable).with(input).and_return(coerced)
+    end
+
+    it { should eql(coerced) }
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Observer::NULL, '#call' do
+  subject { object.call(input) }
+
+  let(:object) { described_class }
+  let(:input)  { mock   }
+
+  it_should_behave_like 'a command method'
+
+  it { should be_kind_of(Observer) }
+end

data/spec/unit/substation/request/env_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Request, '#env' do
+
+  subject { object.env }
+
+  let(:object) { described_class.new(env, input) }
+  let(:env)    { mock }
+  let(:input)  { mock }
+
+  it { should equal(env) }
+end

data/spec/unit/substation/request/error_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Request, '#error' do
+
+  subject { object.error(output) }
+
+  let(:object) { described_class.new(env, input) }
+  let(:env)    { mock }
+  let(:input)  { mock }
+  let(:output) { mock }
+
+  it { should eql(Response::Failure.new(object, output)) }
+end

data/spec/unit/substation/request/input_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Request, '#input' do
+
+  subject { object.input }
+
+  let(:object) { described_class.new(env, input) }
+  let(:env)    { mock }
+  let(:input)  { mock }
+
+  it { should equal(input) }
+end

data/spec/unit/substation/request/success_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Request, '#success' do
+
+  subject { object.success(output) }
+
+  let(:object) { described_class.new(env, input) }
+  let(:env)    { mock }
+  let(:input)  { mock }
+  let(:output) { mock }
+
+  it { should eql(Response::Success.new(object, output)) }
+end

data/spec/unit/substation/response/env_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Response, '#env' do
+
+  subject { object.env }
+
+  let(:object)   { Class.new(described_class).new(request, output) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+  let(:output)   { mock }
+
+  it { should equal(env) }
+end

data/spec/unit/substation/response/failure/success_predicate_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Response::Failure, '#success?' do
+  subject { object.success? }
+
+  let(:object)  { described_class.new(request, output) }
+  let(:request) { Request.new(env, input) }
+  let(:env)     { mock }
+  let(:input)   { mock }
+  let(:output)  { mock }
+
+  it { should be(false) }
+end

data/spec/unit/substation/response/input_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Response, '#input' do
+
+  subject { object.input }
+
+  let(:object)   { Class.new(described_class).new(request, output) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+  let(:output)   { mock }
+
+  it { should equal(input) }
+end

data/spec/unit/substation/response/output_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Response, '#output' do
+
+  subject { object.output }
+
+  let(:object)   { Class.new(described_class).new(request, output) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+  let(:output)   { mock }
+
+  it { should equal(output) }
+end

data/spec/unit/substation/response/success/success_predicate_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Response::Success, '#success?' do
+  subject { object.success? }
+
+  let(:object)  { described_class.new(request, output) }
+  let(:request) { Request.new(env, input) }
+  let(:env)     { mock }
+  let(:input)   { mock }
+  let(:output)  { mock }
+
+  it { should be(true) }
+end

data/spec/unit/substation/utils/class_methods/coerce_callable_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Utils, '.coerce_callable' do
+
+  subject { described_class.coerce_callable(handler) }
+
+  context "with a String handler" do
+    let(:handler) { 'Spec::Action::Success' }
+
+    it { should be(Spec::Action::Success) }
+  end
+
+  context "with a Symbol handler" do
+    let(:handler) { :'Spec::Action::Success' }
+
+    it { should be(Spec::Action::Success) }
+  end
+
+  context "with a Proc handler" do
+    let(:handler) { Proc.new { |response| respone } }
+
+    it { should be(handler) }
+  end
+
+  context "with an unsupported handler" do
+    let(:handler) { mock }
+
+    specify do
+      expect { subject }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/unit/substation/utils/class_methods/const_get_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Utils, '.const_get' do
+
+  subject { described_class.const_get(name) }
+
+  context "with a toplevel constant" do
+    context "given as String" do
+      let(:name) { 'Substation' }
+
+      it { should == Substation }
+    end
+
+    context "given as Symbol" do
+      let(:name) { :Substation }
+
+      it { should == Substation }
+    end
+  end
+
+  context "with a FQN toplevel constant" do
+    let(:name) { '::Substation' }
+
+    it { should == Substation }
+  end
+
+  context "with a nested constant" do
+    let(:name) { 'Substation::Request' }
+
+    it { should == Substation::Request }
+  end
+
+  context "with a non-existant nested constant" do
+    let(:name) { 'Substation::Foo' }
+
+    before do
+      Substation.should_receive(:const_missing).with('Foo').and_raise(NameError)
+    end
+
+    specify do
+      expect { subject }.to raise_error(NameError)
+    end
+  end
+end

data/spec/unit/substation/utils/class_methods/symbolize_keys_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Utils, '.symbolize_keys' do
+
+  subject { described_class.symbolize_keys(hash) }
+
+  context "with no nested hash" do
+    let(:hash) { { 'foo' => 'bar' } }
+
+    it { should == { :foo => 'bar'} }
+  end
+
+  context "with a nested hash" do
+    let(:hash) { { 'foo' => { 'bar' => 'baz' } } }
+
+    it { should == { :foo => { :bar => 'baz'} } }
+  end
+end

data/substation.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/substation/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "substation"
+  gem.version     = Substation::VERSION.dup
+  gem.authors     = [ "Martin Gamsjaeger (snusnu)" ]
+  gem.email       = [ "gamsnjaga@gmail.com" ]
+  gem.description = "Implement application boundary interfaces with dedicated classes"
+  gem.summary     = "Think of it as a domain level request router. It assumes that every usecase in your application has a name and is implemented in a dedicated action handler (class)."
+  gem.homepage    = "https://github.com/snusnu/substation"
+
+  gem.require_paths    = [ "lib" ]
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE README.md TODO]
+
+  gem.add_dependency 'adamantium',          '~> 0.0.7'
+  gem.add_dependency 'equalizer',           '~> 0.0.5'
+  gem.add_dependency 'abstract_type',       '~> 0.0.5'
+  gem.add_dependency 'concord',             '~> 0.0.3'
+
+  gem.add_development_dependency 'bundler', '~> 1.3.5'
+end