substation 0.0.10.beta2 → 0.0.10

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

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Chain::DSL::Builder, '.call' do
-  subject { described_class.call(registry) }
-
-  let(:registry) { { :test => Spec::Processor } }
-
-  let(:builder) { double(:dsl => dsl) }
-  let(:dsl)     { double }
-
-  before do
-    described_class.should_receive(:new).with(registry).and_return(builder)
-    builder.should_receive(:dsl).and_return(dsl)
-  end
-
-  it { should be(dsl) }
-end

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

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Chain::DSL::Builder, '#dsl' do
-  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)      { lambda { |_| test(Spec::FAKE_HANDLER) } }
-  let(:processor)  { Spec::FAKE_PROCESSOR }
-
-  its(:processors) { should include(processor) }
-
-  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

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

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Chain::DSL, '#chain' do
-  subject { object.chain(other) }
-
-  let(:object)    { described_class.new(env, chain) }
-  let(:env)       { Spec::FAKE_ENV }
-  let(:chain)     { Chain::EMPTY }
-  let(:other)     { [ processor ] }
-  let(:processor) { Spec::FAKE_PROCESSOR }
-
-  its(:processors) { should include(processor) }
-end

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

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

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

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Chain::DSL, '#processors' do
-  subject { object.processors }
-
-  let(:env)       { Spec::FAKE_ENV }
-  let(:processor) { 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(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

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Chain::DSL, '#use' do
-  subject { object.use(processor) }
-
-  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) }
-end

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

@@ -1,46 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Chain, '#each' do
-  subject { object.each { |tuple| yields << processor } }
-
-  let(:object)     { described_class.new(processors) }
-  let(:processors) { [ processor ] }
-  let(:processor)  { Spec::FAKE_PROCESSOR }
-  let(:yields)     { [] }
-
-  before do
-    object.should be_instance_of(described_class)
-  end
-
-  it_should_behave_like 'an #each method'
-
-  it 'yields only processors' do
-    subject
-    yields.each { |processor| processor.should be_instance_of(Spec::Processor) }
-  end
-
-  it 'yields only processors with the expected handler' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ processor ])
-  end
-end
-
-describe Chain do
-  subject { described_class.new(processors) }
-
-  let(:processors) { [ processor ] }
-  let(:processor)  { Spec::FAKE_PROCESSOR }
-
-  before do
-    subject.should be_instance_of(described_class)
-  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

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

@@ -1,25 +0,0 @@
-# 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/chain/outgoing/result_spec.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Chain::Outgoing, '#result' do
-
-  subject { object.result(response) }
-
-  let(:object) {
-    Class.new {
-      include Substation::Chain::Outgoing
-    }.new
-  }
-
-  let(:response) { Response::Success.new(request, input) }
-  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

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Dispatcher::Action, '#call' do
-
-  subject { object.call(request) }
-
-  let(:object)   { described_class.new(klass, observer) }
-  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)
-    observer.should_receive(:call).with(response)
-  end
-
-  it { should eql(response) }
-end

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

@@ -1,61 +0,0 @@
-# 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 config is a hash" do
-    context "and 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
-
-  context "when config is no hash" do
-    let(:config)         { action }
-    let(:observer_value) { nil }
-    let(:observer)       { Observer::NULL }
-
-    before do
-      Observer.should_receive(:coerce).with(observer_value).and_return(observer)
-      Utils.should_receive(:coerce_callable).with(config).and_return(action)
-    end
-
-    it { should eql(coerced) }
-  end
-end

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

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

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

@@ -1,47 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Dispatcher, '#call' do
-
-  subject { object.call(action_name, input) }
-
-  let(:object)  { described_class.coerce(config, env) }
-  let(:config)  { { 'test' => { 'action' => 'Spec::Action::Success' } } }
-  let(:request) { Request.new(env, input) }
-  let(:input)   { double }
-  let(:env)     { double }
-
-  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