substation 0.0.10.beta2 → 0.0.10

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

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Dispatcher, '.coerce' do
-
-  subject { described_class.coerce(config, env) }
-
-  let(:config) {{
-    'test' => { 'action' => 'Spec::Action::Success' }
-  }}
-
-  let(:env) { double }
-
-  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,50 +0,0 @@
-require 'spec_helper'
-
-describe Substation::Environment, '#chain' do
-
-  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(&block) }
-  let(:block)    { lambda { |_| register(:test, Spec::Processor) } }
-
-  let(:expected) { Chain.new(processors) }
-
-  context "when other is not given" do
-    context "and a block is given" do
-      subject { object.chain(&chain) }
-
-      let(:processors) { dsl.processors(object, other, &chain) }
-
-      it { should eql(expected) }
-    end
-
-    context "and no block is given" do
-      subject { object.chain }
-
-      let(:processors) { dsl.processors(object, other) }
-
-      it { should eql(expected) }
-    end
-  end
-
-  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(expected) }
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe Substation::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) }
-
-  it { should eql(expected) }
-end

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

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe Substation::Environment::DSL, '.registry' do
-  context "when a block is given" do
-    subject { described_class.registry(&block) }
-
-    let(:block)    { lambda { |_| register :test, Spec::Processor } }
-    let(:expected) { { :test => Spec::Processor } }
-
-    it { should eql(expected) }
-  end
-
-  context "when no block is given" do
-    subject { described_class.registry }
-
-    it { should eql({}) }
-  end
-end

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

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Substation::Environment::DSL, '#register' do
-  subject { object.register(name, processor) }
-
-  let(:object)    { described_class.new }
-  let(:name)      { :test }
-  let(:processor) { Spec::Processor }
-
-  let(:expected) { { :test => Spec::Processor } }
-  let(:block)    { lambda { |_| register :test, Spec::Processor } }
-
-  its(:registry) { should eql(expected) }
-end

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

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Substation::Environment::DSL, '#registry' do
-  subject { object.registry }
-
-  context "when a block is given" do
-    let(:object)   { described_class.new(&block) }
-    let(:block)    { lambda { |_| register :test, Spec::Processor } }
-    let(:expected) { { :test => Spec::Processor } }
-
-    it { should eql(expected) }
-  end
-
-  context "when no block is given" do
-    let(:object) { described_class.new }
-
-    it { should eql({}) }
-  end
-end

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

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Observer::Chain, '#call' do
-  subject { object.call(response) }
-
-  let(:object) { Observer::Chain.new(observers) }
-
-  let(:response)   { double('Response') }
-  let(:observer_a) { double('Observer A') }
-  let(:observer_b) { double('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

@@ -1,33 +0,0 @@
-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)   { double }
-    let(:coerced) { double }
-
-    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

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

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

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Evaluator, '#call' do
-  subject { object.call(request) }
-
-  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 "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)) } }
-
-    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, Spec::Presenter.new(:failure)) }
-
-      it { should eql(response) }
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Wrapper, '#call' do
-  subject { object.call(response) }
-
-  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) }
-
-  it { should eql(wrapped) }
-end

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

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

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

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Request, '#error' do
-
-  subject { object.error(output) }
-
-  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

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

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

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Request, '#success' do
-
-  subject { object.success(output) }
-
-  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

@@ -1,16 +0,0 @@
-# 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)      { double }
-  let(:input)    { double }
-  let(:output)   { double }
-
-  it { should equal(env) }
-end

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

@@ -1,15 +0,0 @@
-# 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)     { double }
-  let(:input)   { double }
-  let(:output)  { double }
-
-  it { should be(false) }
-end

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

@@ -1,16 +0,0 @@
-# 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)      { double }
-  let(:input)    { double }
-  let(:output)   { double }
-
-  it { should equal(input) }
-end

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

@@ -1,16 +0,0 @@
-# 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)      { double }
-  let(:input)    { double }
-  let(:output)   { double }
-
-  it { should equal(output) }
-end

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

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