substation 0.0.9 → 0.0.10.beta2

data/spec/unit/substation/chain/dsl/builder/class_methods/call_spec.rb

@@ -7,8 +7,8 @@ describe Chain::DSL::Builder, '.call' do
 
   let(:registry) { { :test => Spec::Processor } }
 
-  let(:builder) { mock(:dsl => dsl) }
-  let(:dsl)     { mock }
+  let(:builder) { double(:dsl => dsl) }
+  let(:dsl)     { double }
 
   before do
     described_class.should_receive(:new).with(registry).and_return(builder)

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

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

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe "Initializing a processor's failure chain" do
+  subject { chain.call(request) }
+
+  let(:env) {
+    Environment.build {
+      register :evaluate, Processor::Evaluator
+      register :wrap,     Processor::Wrapper
+    }
+  }
+
+  let(:chain) {
+    env.chain {
+      evaluate(Spec::Handler::Evaluator) {
+        wrap Spec::Presenter
+      }
+    }
+  }
+
+  let(:request) { Request.new(app_env, input) }
+  let(:app_env) { double }
+  let(:input)   { :invalid }
+
+  let(:response) { Response::Failure.new(request, Spec::Presenter.new(:failure)) }
+
+  it { should eql(response) }
+end

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

@@ -5,7 +5,8 @@ require 'spec_helper'
 describe Chain::DSL, '#chain' do
   subject { object.chain(other) }
 
-  let(:object)    { described_class.new(chain) }
+  let(:object)    { described_class.new(env, chain) }
+  let(:env)       { Spec::FAKE_ENV }
   let(:chain)     { Chain::EMPTY }
   let(:other)     { [ processor ] }
   let(:processor) { Spec::FAKE_PROCESSOR }

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

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

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+# Test wether env is correctly passed down
+describe Chain::DSL, '#initialize' do
+  subject { dsl.new(env, processors, &block) }
+
+  let(:env)        { Spec::FAKE_ENV }
+  let(:dsl)        { builder.dsl }
+  let(:builder)    { described_class::Builder.new(registry) }
+  let(:registry)   { { :test => Spec::Processor } }
+  let(:processors) { [] }
+  let(:block)      { lambda { |_| test(Spec::FAKE_HANDLER) } }
+
+  let(:processor)  { Spec::FAKE_PROCESSOR }
+
+  its(:processors) { should include(processor) }
+end

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

@@ -5,26 +5,38 @@ require 'spec_helper'
 describe Chain::DSL, '#processors' do
   subject { object.processors }
 
+  let(:env)       { Spec::FAKE_ENV }
   let(:processor) { Spec::FAKE_PROCESSOR }
-  let(:name)      { mock }
 
-  context 'and a block is given' do
-    let(:object) { described_class.new(chain, &block) }
-    let(:chain)  { EMPTY_ARRAY }
-    let(:block)  { ->(_) { use(Spec::FAKE_PROCESSOR) } }
+  context "and a block is given" do
+    let(:object) { described_class.new(env, chain, &block) }
+    let(:chain)  { Chain::EMPTY }
+    let(:block)  { lambda { |_| use(Spec::FAKE_PROCESSOR) } }
 
     it { should include(processor) }
 
     its(:length) { should == 1 }
   end
 
-  context 'and no block is given' do
-    let(:object) { described_class.new(chain) }
-    let(:chain)  { Chain.new([ processor ], failure_chain) }
-    let(:failure_chain) { mock }
+  context "and no block is given" do
+    let(:object) { described_class.new(env, chain) }
+    let(:chain)  { Chain.new([ processor ]) }
 
     it { should include(processor) }
 
     its(:length) { should == 1 }
   end
+
+  # TODO move this elsewhere once mutant supports it
+  context "test DSL#initialize" do
+    let(:object) { described_class.new(env, chain, &block) }
+    let(:chain)  { Chain::EMPTY }
+    let(:block)  { lambda { |_| use(Spec::FAKE_PROCESSOR) } }
+
+    it { should include(processor) }
+
+    it "passes down the env to registered processors" do
+      subject.first.env.should be(env)
+    end
+  end
 end

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

@@ -5,8 +5,9 @@ require 'spec_helper'
 describe Chain::DSL, '#use' do
   subject { object.use(processor) }
 
-  let(:object)    { described_class.new(chain) }
-  let(:chain)     { EMPTY_ARRAY }
+  let(:object)    { described_class.new(env, chain) }
+  let(:env)       { Spec::FAKE_ENV }
+  let(:chain)     { Chain::EMPTY }
   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, described_class::EMPTY) }
+  let(:object)     { described_class.new(processors) }
   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, described_class::EMPTY) }
+  subject { described_class.new(processors) }
 
   let(:processors) { [ processor ] }
   let(:processor)  { Spec::FAKE_PROCESSOR }
@@ -39,4 +39,8 @@ 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/incoming/result_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::Incoming, '#result' do
+
+  subject { object.result(response) }
+
+  let(:object) {
+    Class.new {
+      include Substation::Chain::Incoming
+    }.new
+  }
+
+  let(:response) { Response::Success.new(request, input) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
+
+  it { should eql(request) }
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::Outgoing, '#call' do
+
+  subject { object.call(request) }
+
+  let(:object) {
+    Class.new {
+      include Substation::Chain::Outgoing
+      def call(request)
+        response = request.success(request.input)
+        respond_with(response, :altered)
+      end
+    }.new
+  }
+
+  let(:response) { Response::Success.new(request, :altered) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
+
+  it { should eql(response) }
+end

data/spec/unit/substation/{processor → chain/outgoing}/result_spec.rb

@@ -2,21 +2,20 @@
 
 require 'spec_helper'
 
-describe Processor, '#result' do
+describe Chain::Outgoing, '#result' do
 
   subject { object.result(response) }
 
   let(:object) {
     Class.new {
-      include Substation::Processor
+      include Substation::Chain::Outgoing
     }.new
   }
 
   let(:response) { Response::Success.new(request, input) }
-  let(:request)  { Request.new(name, env, input) }
-  let(:name)     { mock }
-  let(:env)      { mock }
-  let(:input)    { mock }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
 
   it { should be(response) }
 end

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

@@ -7,13 +7,12 @@ 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(name, env, input) }
-  let(:name)     { mock }
-  let(:env)      { mock }
-  let(:input)    { mock }
-  let(:response) { mock }
+  let(:klass)    { double }
+  let(:observer) { double }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
+  let(:response) { double }
 
   before do
     klass.should_receive(:call).with(request).and_return(response)

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

@@ -9,15 +9,13 @@ 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)
@@ -48,7 +46,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/action_names_spec.rb

@@ -8,7 +8,7 @@ describe Dispatcher, '#action_names' do
 
   let(:object) { described_class.new(config, env) }
   let(:config) { { :test => { :action => Spec::Action::Success } } }
-  let(:env)    { mock }
+  let(:env)    { double }
 
   it { should eql(Set[ :test ]) }
 end

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