substation 0.0.8 → 0.0.9

data/spec/unit/substation/chain/class_methods/failure_response_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain, '.failure_response' do
+  subject { described_class.failure_response(request, data, exception) }
+
+  let(:request)   { mock(:env => mock, :input => mock) }
+  let(:data)      { mock }
+  let(:exception) { mock }
+
+  let(:expected)     { Response::Failure.new(request, failure_data) }
+  let(:failure_data) { described_class::FailureData.new(data, exception) }
+
+  it { should eql(expected) }
+end

data/spec/unit/substation/chain/dsl/builder/dsl_spec.rb

@@ -9,12 +9,15 @@ describe Chain::DSL::Builder, '#dsl' do
   let(:builder)    { described_class.new(registry) }
   let(:registry)   { { :test => Spec::Processor } }
   let(:processors) { [] }
-  let(:block)      { lambda { |_| test(Spec::FAKE_HANDLER) } }
+  let(:block)      { ->(_) { test(Spec::FAKE_HANDLER, EMPTY_ARRAY) } }
+
   let(:processor)  { Spec::FAKE_PROCESSOR }
 
-  its(:processors) { should include(processor) }
+  it 'should register instantiated processors' do
+    expect(subject.processors).to include(processor)
+  end
 
-  it "should create a subclass of Chain::DSL" do
-    subject.class.should be < Chain::DSL
+  it 'should create a subclass of Chain::DSL' do
+    expect(subject.class).to be < Chain::DSL
   end
 end

data/spec/unit/substation/chain/dsl/class_methods/build_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL, '.build' do
+
+  let(:chain) { EMPTY_ARRAY }
+  let(:failure_chain) { Chain::EMPTY }
+
+  context 'and a block is given' do
+    subject { described_class.build(chain, failure_chain, &block) }
+
+    let(:block)     { ->(_) { use(Spec::FAKE_PROCESSOR) } }
+    let(:processor) { Spec::FAKE_PROCESSOR }
+
+    it { should include(processor) }
+  end
+
+  context 'and no block is given' do
+    subject { described_class.build(chain, failure_chain) }
+
+    its(:processors) { should be_empty }
+  end
+end

data/spec/unit/substation/chain/dsl/failure_chain_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL, '#failure_chain' do
+  subject { object.failure_chain(name, failure_chain) }
+
+  let(:object)   { dsl.new([ Spec::FAKE_PROCESSOR ]) }
+  let(:dsl)      { described_class::Builder.call(registry) }
+  let(:registry) { Environment::DSL.registry(&block) }
+  let(:block)    { ->(_) { register(:test, Spec::Processor) } }
+
+  let(:processor)     { Spec::FAKE_PROCESSOR.with_failure_chain(failure_chain) }
+  let(:failure_chain) { mock }
+
+  context 'when the processor to alter is registered' do
+    let(:name) { :test }
+
+    its(:processors) { should include(processor) }
+
+    it 'should replace the processor' do
+      expect(subject.processors.length).to be(1)
+    end
+  end
+
+  context 'when the processor to alter is not registered' do
+    let(:name) { :unknown }
+
+    specify {
+      expect {
+        subject
+      }.to raise_error(UnknownProcessor, 'No processor named :unknown is registered')
+    }
+  end
+end

data/spec/unit/substation/chain/dsl/processors_spec.rb

@@ -6,20 +6,22 @@ describe Chain::DSL, '#processors' do
   subject { object.processors }
 
   let(:processor) { Spec::FAKE_PROCESSOR }
+  let(:name)      { mock }
 
-  context "and a block is given" do
-    let(:object)    { described_class.new(chain, &block) }
-    let(:chain) { Chain::EMPTY }
-    let(:block)     { lambda { |_| use(Spec::FAKE_PROCESSOR) } }
+  context 'and a block is given' do
+    let(:object) { described_class.new(chain, &block) }
+    let(:chain)  { EMPTY_ARRAY }
+    let(:block)  { ->(_) { use(Spec::FAKE_PROCESSOR) } }
 
     it { should include(processor) }
 
     its(:length) { should == 1 }
   end
 
-  context "and no block is given" do
+  context 'and no block is given' do
     let(:object) { described_class.new(chain) }
-    let(:chain)  { Chain.new([ processor ]) }
+    let(:chain)  { Chain.new([ processor ], failure_chain) }
+    let(:failure_chain) { mock }
 
     it { should include(processor) }
 

data/spec/unit/substation/chain/dsl/use_spec.rb

@@ -6,7 +6,7 @@ describe Chain::DSL, '#use' do
   subject { object.use(processor) }
 
   let(:object)    { described_class.new(chain) }
-  let(:chain)     { Chain::EMPTY }
+  let(:chain)     { EMPTY_ARRAY }
   let(:processor) { Spec::FAKE_PROCESSOR }
 
   its(:processors) { should include(processor) }

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Chain, '#each' do
   subject { object.each { |tuple| yields << processor } }
 
-  let(:object)     { described_class.new(processors) }
+  let(:object)     { described_class.new(processors, described_class::EMPTY) }
   let(:processors) { [ processor ] }
   let(:processor)  { Spec::FAKE_PROCESSOR }
   let(:yields)     { [] }
@@ -22,14 +22,14 @@ describe Chain, '#each' do
   end
 
   it 'yields only processors with the expected handler' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ processor ])
+    expect { subject }.to change { yields.dup }
+      .from([])
+      .to([ processor ])
   end
 end
 
 describe Chain do
-  subject { described_class.new(processors) }
+  subject { described_class.new(processors, described_class::EMPTY) }
 
   let(:processors) { [ processor ] }
   let(:processor)  { Spec::FAKE_PROCESSOR }
@@ -39,8 +39,4 @@ describe Chain do
   end
 
   it { should be_kind_of(Enumerable) }
-
-  it 'case matches Enumerable' do
-    (Enumerable === subject).should be(true)
-  end
 end

data/spec/unit/substation/chain/failure_data/equalizer_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::FailureData, 'equalizer behavior' do
+  subject { object == other }
+
+  let(:object)    { described_class.new(data, exception) }
+  let(:data)      { mock }
+  let(:exception) { RuntimeError.new }
+
+  let(:other)     { described_class.new(other_data, other_exception) }
+
+  context 'with equal data associated' do
+
+    let(:other_data) { data }
+
+    context 'and equal exception classes' do
+      let(:other_exception) { RuntimeError.new }
+
+      it { should be(true) }
+    end
+
+    context 'and different exception classes' do
+      let(:other_exception) { StandardError.new }
+
+      it { should be(false) }
+    end
+  end
+
+  context 'with different data associated' do
+    let(:other_data) { mock }
+
+    context 'and equal exception classes' do
+      let(:other_exception) { RuntimeError.new }
+
+      it { should be(false) }
+    end
+
+    context 'and different exception classes' do
+      let(:other_exception) { StandardError.new }
+
+      it { should be(false) }
+    end
+  end
+end

data/spec/unit/substation/chain/failure_data/hash_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::FailureData, '#hash' do
+  subject { object.hash }
+
+  let(:object)    { described_class.new(data, exception) }
+  let(:data)      { mock }
+  let(:exception) { mock }
+
+  it { should eql(described_class.hash ^ data.hash ^ exception.class.hash) }
+end

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

@@ -9,7 +9,8 @@ describe Dispatcher::Action, '#call' do
   let(:object)   { described_class.new(klass, observer) }
   let(:klass)    { mock }
   let(:observer) { mock }
-  let(:request)  { Request.new(env, input) }
+  let(:request)  { Request.new(name, env, input) }
+  let(:name)     { mock }
   let(:env)      { mock }
   let(:input)    { mock }
   let(:response) { mock }

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

@@ -9,13 +9,15 @@ describe Dispatcher::Action, '.coerce' do
   let(:action)  { Spec::Action::Success }
   let(:coerced) { Dispatcher::Action.new(action, observer) }
 
-  context "when config is a hash" do
-    context "and coercion is possible" do
+  context 'when config is a hash' do
+    context 'and coercion is possible' do
 
-      let(:config) {{
+      let(:config) {
+        {
           :action   => action,
           :observer => observer_value
-      }}
+        }
+      }
 
       before do
         Observer.should_receive(:coerce).with(observer_value).and_return(observer)
@@ -46,7 +48,7 @@ describe Dispatcher::Action, '.coerce' do
     end
   end
 
-  context "when config is no hash" do
+  context 'when config is no hash' do
     let(:config)         { action }
     let(:observer_value) { nil }
     let(:observer)       { Observer::NULL }

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

@@ -8,9 +8,9 @@ describe Dispatcher, '#call' do
 
   let(:object)  { described_class.coerce(config, env) }
   let(:config)  { { 'test' => { 'action' => 'Spec::Action::Success' } } }
-  let(:request) { Request.new(env, input) }
-  let(:input)   { mock }
+  let(:request) { Request.new(action_name, env, input) }
   let(:env)     { mock }
+  let(:input)   { mock }
 
   let(:expected_response) do
     Spec::Action::Success.call(request)

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

@@ -6,15 +6,15 @@ describe Dispatcher, '.coerce' do
 
   subject { described_class.coerce(config, env) }
 
-  let(:config) {{
-    'test' => { 'action' => 'Spec::Action::Success' }
-  }}
+  let(:config) {
+    { 'test' => { 'action' => 'Spec::Action::Success' } }
+  }
 
   let(:env) { mock }
 
-  let(:coerced) {{
-    :test => described_class::Action.coerce(:action => 'Spec::Action::Success')
-  }}
+  let(:coerced) {
+    { :test => described_class::Action.coerce(:action => 'Spec::Action::Success') }
+  }
 
   it { should eql(described_class.new(coerced, env)) }
 end

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

@@ -1,45 +1,40 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Substation::Environment, '#chain' do
 
-  let(:object) { described_class.build(&block) }
+  let(:object) { described_class.new(registry, dsl) }
 
-  let(:expected) { Chain.build(dsl, other, &chain) }
-  let(:other)    { Chain::EMPTY }
-  let(:chain)    { lambda { |_| test Spec::FAKE_HANDLER } }
   let(:dsl)      { Chain::DSL::Builder.call(registry) }
-  let(:registry) { described_class::DSL.registry(&block) }
-  let(:block)    { lambda { |_| register(:test, Spec::Processor) } }
+  let(:registry) { described_class::DSL.registry(&r_block) }
+  let(:r_block)  { ->(_) { register(:test, Spec::Processor) } }
 
-  context "when other is not given" do
-    context "and a block is given" do
-      subject { object.chain(&chain) }
+  let(:other)         { mock('other', :each => EMPTY_ARRAY) }
+  let(:failure_chain) { mock('failure_chain') }
+  let(:block)         { ->(_) { test Spec::FAKE_HANDLER, Chain::EMPTY } }
 
-      it { should eql(expected) }
-    end
+  context 'when other, failure_chain and block are given' do
+    subject { object.chain(other, failure_chain, &block) }
 
-    context "and no block is given" do
-      subject { object.chain }
+    it { should eql(dsl.build(other, failure_chain, &block)) }
+  end
 
-      let(:expected) { Chain.build(dsl, other) }
+  context 'when other, failure_chain and no block are given' do
+    subject { object.chain(other, failure_chain) }
 
-      it { should eql(expected) }
-    end
+    it { should eql(dsl.build(other, failure_chain)) }
   end
 
-  context "when other is given" do
-    context "and a block is given" do
-      subject { object.chain(other, &chain) }
+  context 'when other, no failure_chain and no block are given' do
+    subject { object.chain(other) }
 
-      it { should eql(expected) }
-    end
-
-    context "and no block is given" do
-      subject { object.chain(other) }
+    it { should eql(dsl.build(other, Chain::EMPTY)) }
+  end
 
-      let(:expected) { Chain.build(dsl, other) }
+  context 'when no parameters are given' do
+    subject { object.chain }
 
-      it { should eql(expected) }
-    end
+    it { should eql(dsl.build(Chain::EMPTY, Chain::EMPTY)) }
   end
 end

data/spec/unit/substation/environment/class_methods/build_spec.rb

@@ -1,11 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Substation::Environment, '.build' do
+describe Environment, '.build' do
   subject { described_class.build(&block) }
 
-  let(:block)    { lambda { |_| register(:test, Substation) } }
-  let(:expected) { described_class.new(registry) }
-  let(:registry) { described_class::DSL.registry(&block) }
+  let(:expected)  { Environment.new(registry, chain_dsl) }
+  let(:chain_dsl) { Chain::DSL::Builder.call(registry) }
+  let(:registry)  { described_class::DSL.new(&block).registry }
+  let(:block)     { ->(_) { register(:test, Substation) } }
 
   it { should eql(expected) }
+
+  it 'uses the compiled dsl' do
+    expect(subject.chain).to eql(chain_dsl.build(Chain::EMPTY, Chain::EMPTY))
+  end
 end

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

@@ -1,16 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Substation::Environment::DSL, '.registry' do
-  context "when a block is given" do
+  context 'when a block is given' do
     subject { described_class.registry(&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
     subject { described_class.registry }
 
     it { should eql({}) }

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

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Substation::Environment::DSL, '#register' do
+describe Environment::DSL, '#register' do
   subject { object.register(name, processor) }
 
   let(:object)    { described_class.new }
@@ -8,7 +10,10 @@ describe Substation::Environment::DSL, '#register' do
   let(:processor) { Spec::Processor }
 
   let(:expected) { { :test => Spec::Processor } }
-  let(:block)    { lambda { |_| register :test, Spec::Processor } }
 
-  its(:registry) { should eql(expected) }
+  it_behaves_like 'a command method'
+
+  it 'registers the given processor' do
+    expect(subject.registry).to eql(expected)
+  end
 end