substation 0.0.9 → 0.0.10.beta2

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

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

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

@@ -1,19 +1,17 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
 describe Substation::Environment::DSL, '#registry' do
   subject { object.registry }
 
-  context 'when a block is given' do
+  context "when a block is given" do
     let(:object)   { described_class.new(&block) }
-    let(:block)    { ->(_) { register :test, Spec::Processor } }
+    let(:block)    { lambda { |_| 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
     let(:object) { described_class.new }
 
     it { should eql({}) }

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

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
 describe Observer::Chain, '#call' do
@@ -7,9 +5,9 @@ describe Observer::Chain, '#call' do
 
   let(:object) { Observer::Chain.new(observers) }
 
-  let(:response)   { mock('Response') }
-  let(:observer_a) { mock('Observer A') }
-  let(:observer_b) { mock('Observer B') }
+  let(:response)   { double('Response') }
+  let(:observer_a) { double('Observer A') }
+  let(:observer_b) { double('Observer B') }
 
   let(:observers) { [observer_a, observer_b] }
 

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

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
 describe Observer, '.coerce' do
@@ -23,8 +21,8 @@ describe Observer, '.coerce' do
   end
 
   context 'with other input' do
-    let(:input)   { mock }
-    let(:coerced) { mock }
+    let(:input)   { double }
+    let(:coerced) { double }
 
     before do
       Utils.should_receive(:coerce_callable).with(input).and_return(coerced)

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

@@ -1,12 +1,10 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
 describe Observer::NULL, '#call' do
   subject { object.call(input) }
 
   let(:object) { described_class }
-  let(:input)  { mock   }
+  let(:input)  { double   }
 
   it_should_behave_like 'a command method'
 

data/spec/unit/substation/processor/evaluator/call_spec.rb

@@ -5,31 +5,45 @@ require 'spec_helper'
 describe Processor::Evaluator, '#call' do
   subject { object.call(request) }
 
-  let(:object)           { klass.new(processor_name, handler, failure_chain) }
-  let(:processor_name)   { mock }
-  let(:klass)            { Class.new(described_class) { include Processor::Incoming } }
-  let(:failure_chain)    { mock(:call => failure_response) }
-  let(:failure_response) { mock }
-  let(:request)          { Request.new(action_name, env, input) }
-  let(:action_name)      { mock }
-  let(:env)              { mock }
-  let(:input)            { mock }
-
-  context 'with a successful handler' do
-    let(:handler)  { Spec::Action::Success }
-    let(:response) { Response::Success.new(request, Spec.response_data) }
-
-    it { should eql(response) }
+  let(:request) { Request.new(double('env'), input) }
+
+  context "when no failure chain is registered" do
+
+    let(:object) { described_class.new(Spec::FAKE_ENV, Spec::Handler::Evaluator.new) }
+
+    context "when evaluation is successful" do
+      let(:input)    { :success }
+      let(:response) { Response::Success.new(request, input) }
+
+      it { should eql(response) }
+    end
+
+    context "when evaluation is not successful" do
+      let(:input)    { :invalid }
+      let(:response) { Response::Failure.new(request, :failure) }
+
+      it { should eql(response) }
+    end
   end
 
-  context 'with a failing handler' do
-    let(:handler)  { Spec::Action::Failure }
-    let(:response) { Response::Failure.new(request, Spec.response_data) }
+  context "when a failure chain is registered" do
+
+    let(:object) { described_class.new(env, Spec::Handler::Evaluator.new, &block) }
+    let(:env)    { Environment.new({}) }
+    let(:block)  { lambda { |_| use(Processor::Wrapper.new(env, Spec::Presenter)) } }
 
-    before do
-      failure_chain.should_receive(:call).with(response).and_return(failure_response)
+    context "when evaluation is successful" do
+      let(:input)    { :success }
+      let(:response) { Response::Success.new(request, input) }
+
+      it { should eql(response) }
     end
 
-    it { should eql(failure_response) }
+    context "when evaluation is not successful" do
+      let(:input)    { :invalid }
+      let(:response) { Response::Failure.new(request, Spec::Presenter.new(:failure)) }
+
+      it { should eql(response) }
+    end
   end
 end

data/spec/unit/substation/processor/pivot/call_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Pivot, '#call' do
+  subject { object.call(request) }
+
+  let(:object)  { described_class.new(s_env, Spec::Handler::Pivot.new) }
+  let(:s_env)   { double }
+  let(:request) { Request.new(env, input) }
+  let(:env)     { double }
+  let(:input)   { double }
+
+  let(:response) { Response::Success.new(request, request.input) }
+
+  it { should eql(response) }
+end

data/spec/unit/substation/processor/wrapper/call_spec.rb

@@ -5,14 +5,13 @@ require 'spec_helper'
 describe Processor::Wrapper, '#call' do
   subject { object.call(response) }
 
-  let(:object)         { described_class.new(processor_name, Spec::Presenter) }
-  let(:processor_name) { mock }
-  let(:response)       { Response::Success.new(request, output) }
-  let(:request)        { Request.new(action_name, env, input) }
-  let(:action_name)    { mock }
-  let(:env)            { mock }
-  let(:input)          { mock }
-  let(:output)         { mock }
+  let(:object)   { described_class.new(s_env, Spec::Presenter) }
+  let(:s_env)    { double }
+  let(:response) { Response::Success.new(request, output) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
+  let(:output)   { double }
 
   let(:wrapped) { Response::Success.new(request, data) }
   let(:data)    { Spec::Presenter.new(output) }

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

@@ -6,10 +6,9 @@ describe Request, '#env' do
 
   subject { object.env }
 
-  let(:object) { described_class.new(name, env, input) }
-  let(:name)   { mock }
-  let(:env)    { mock }
-  let(:input)  { mock }
+  let(:object) { described_class.new(env, input) }
+  let(:env)    { double }
+  let(:input)  { double }
 
-  it { should be(env) }
+  it { should equal(env) }
 end

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

@@ -6,11 +6,10 @@ describe Request, '#error' do
 
   subject { object.error(output) }
 
-  let(:object) { described_class.new(name, env, input) }
-  let(:name)   { mock }
-  let(:env)    { mock }
-  let(:input)  { mock }
-  let(:output) { mock }
+  let(:object) { described_class.new(env, input) }
+  let(:env)    { double }
+  let(:input)  { double }
+  let(:output) { double }
 
   it { should eql(Response::Failure.new(object, output)) }
 end

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

@@ -6,10 +6,9 @@ describe Request, '#input' do
 
   subject { object.input }
 
-  let(:object) { described_class.new(name, env, input) }
-  let(:name)   { mock }
-  let(:env)    { mock }
-  let(:input)  { mock }
+  let(:object) { described_class.new(env, input) }
+  let(:env)    { double }
+  let(:input)  { double }
 
-  it { should be(input) }
+  it { should equal(input) }
 end

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

@@ -6,11 +6,10 @@ describe Request, '#success' do
 
   subject { object.success(output) }
 
-  let(:object) { described_class.new(name, env, input) }
-  let(:name)   { mock }
-  let(:env)    { mock }
-  let(:input)  { mock }
-  let(:output) { mock }
+  let(:object) { described_class.new(env, input) }
+  let(:env)    { double }
+  let(:input)  { double }
+  let(:output) { double }
 
   it { should eql(Response::Success.new(object, output)) }
 end

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

@@ -7,11 +7,10 @@ describe Response, '#env' do
   subject { object.env }
 
   let(:object)   { Class.new(described_class).new(request, output) }
-  let(:request)  { Request.new(name, env, input) }
-  let(:name)     { mock }
-  let(:env)      { mock }
-  let(:input)    { mock }
-  let(:output)   { mock }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
+  let(:output)   { double }
 
-  it { should be(env) }
+  it { should equal(env) }
 end

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

@@ -6,11 +6,10 @@ describe Response::Failure, '#success?' do
   subject { object.success? }
 
   let(:object)  { described_class.new(request, output) }
-  let(:request) { Request.new(name, env, input) }
-  let(:name)    { mock }
-  let(:env)     { mock }
-  let(:input)   { mock }
-  let(:output)  { mock }
+  let(:request) { Request.new(env, input) }
+  let(:env)     { double }
+  let(:input)   { double }
+  let(:output)  { double }
 
   it { should be(false) }
 end

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

@@ -7,11 +7,10 @@ describe Response, '#input' do
   subject { object.input }
 
   let(:object)   { Class.new(described_class).new(request, output) }
-  let(:request)  { Request.new(name, env, input) }
-  let(:name)     { mock }
-  let(:env)      { mock }
-  let(:input)    { mock }
-  let(:output)   { mock }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
+  let(:output)   { double }
 
-  it { should be(input) }
+  it { should equal(input) }
 end

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

@@ -7,11 +7,10 @@ describe Response, '#output' do
   subject { object.output }
 
   let(:object)   { Class.new(described_class).new(request, output) }
-  let(:request)  { Request.new(name, env, input) }
-  let(:name)     { mock }
-  let(:env)      { mock }
-  let(:input)    { mock }
-  let(:output)   { mock }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
+  let(:output)   { double }
 
   it { should equal(output) }
 end

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

@@ -7,11 +7,10 @@ describe Response, '#request' do
   subject { object.request }
 
   let(:object)   { Class.new(described_class).new(request, output) }
-  let(:request)  { Request.new(name, env, input) }
-  let(:name)     { mock }
-  let(:env)      { mock }
-  let(:input)    { mock }
-  let(:output)   { mock }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { double }
+  let(:input)    { double }
+  let(:output)   { double }
 
-  it { should be(request) }
+  it { should equal(request) }
 end

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

@@ -6,11 +6,10 @@ describe Response::Success, '#success?' do
   subject { object.success? }
 
   let(:object)  { described_class.new(request, output) }
-  let(:request) { Request.new(name, env, input) }
-  let(:name)    { mock }
-  let(:env)     { mock }
-  let(:input)   { mock }
-  let(:output)  { mock }
+  let(:request) { Request.new(env, input) }
+  let(:env)     { double }
+  let(:input)   { double }
+  let(:output)  { double }
 
   it { should be(true) }
 end

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

@@ -6,40 +6,38 @@ describe Utils, '.coerce_callable' do
 
   subject { described_class.coerce_callable(handler) }
 
-  let(:const) { Spec::Action::Success }
-
-  context 'with a String handler' do
-    let(:handler) { const.name }
+  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) { const.name.to_sym }
+  context "with a Symbol handler" do
+    let(:handler) { :'Spec::Action::Success' }
 
     it { should be(Spec::Action::Success) }
   end
 
-  context 'with a const handler' do
-    let(:handler) { const }
+  context "with a const handler" do
+    let(:handler) { Spec::Action::Success }
 
-    it { should be(const) }
+    it { should be(Spec::Action::Success) }
   end
 
-  context 'with a Proc handler' do
-    let(:handler) { ->(response) { response } }
+  context "with a Proc handler" do
+    let(:handler) { Proc.new { |response| respone } }
 
     it { should be(handler) }
   end
 
-  context 'with a Chain handler' do
-    let(:handler) { Chain.new(EMPTY_ARRAY, Chain::EMPTY) }
+  context "with a Chain handler" do
+    let(:handler) { Chain.new([]) }
 
     it { should be(handler) }
   end
 
-  context 'with an unsupported handler' do
-    let(:handler) { mock }
+  context "with an unsupported handler" do
+    let(:handler) { double }
 
     specify do
       expect { subject }.to raise_error(ArgumentError)