substation 0.0.9 → 0.0.10.beta2

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

@@ -1,13 +0,0 @@
-# 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/environment/equalizer_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Substation::Environment, 'equalizer behavior' do
-  subject { object == other }
-
-  let(:object) { described_class.new(registry, dsl) }
-  let(:other)  { described_class.new(other_registry, dsl) }
-
-  let(:registry) { mock }
-  let(:dsl)      { mock }
-
-  context 'with an equal registry' do
-    let(:other_registry) { registry }
-
-    it { should be(true) }
-  end
-
-  context 'with a different registry' do
-    let(:other_registry) { mock }
-
-    it { should be(false) }
-  end
-end

data/spec/unit/substation/processor/evaluator/class_methods/new_spec.rb

@@ -1,9 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Evaluator, '.new' do
-  subject { object.new }
-
-  it_behaves_like 'an abstract type'
-end

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

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Evaluator::Data, '#call' do
-  subject { object.call(request) }
-
-  let(:object)           { described_class.new(processor_name, handler, failure_chain) }
-  let(:processor_name)   { mock }
-  let(:failure_chain)    { mock(:call => failure_response) }
-  let(:failure_response) { mock }
-  let(:handler)          { Spec::Handler::Evaluator }
-  let(:request)          { Request.new(action_name, env, input) }
-  let(:action_name)      { mock }
-  let(:env)              { mock }
-
-  context 'with a successful handler' do
-    let(:input)    { :success }
-    let(:response) { request.success(input) }
-
-    it { should eql(response) }
-  end
-
-  context 'with a failing handler' do
-    let(:input)    { :foo }
-    let(:response) { request.error(:failure) }
-
-    before do
-      failure_chain.should_receive(:call).with(response).and_return(failure_response)
-    end
-
-    it { should eql(failure_response) }
-  end
-end

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

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Evaluator::Pivot, '#call' do
-  subject { object.call(request) }
-
-  let(:object)           { described_class.new(processor_name, handler, failure_chain) }
-  let(:processor_name)   { mock }
-  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) }
-  end
-
-  context 'with a failing handler' do
-    let(:handler)  { Spec::Action::Failure }
-    let(:response) { Response::Failure.new(request, Spec.response_data) }
-
-    before do
-      failure_chain.should_receive(:call).with(response).and_return(failure_response)
-    end
-
-    it { should eql(failure_response) }
-  end
-end

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

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Evaluator::Request, '#call' do
-  subject { object.call(request) }
-
-  let(:object)           { described_class.new(processor_name, handler, failure_chain) }
-  let(:processor_name)   { mock }
-  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) }
-  end
-
-  context 'with a failing handler' do
-    let(:handler)  { Spec::Action::Failure }
-    let(:response) { Response::Failure.new(request, Spec.response_data) }
-
-    before do
-      failure_chain.should_receive(:call).with(response).and_return(failure_response)
-    end
-
-    it { should eql(failure_response) }
-  end
-end

data/spec/unit/substation/processor/fallible/name_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Fallible, '#name' do
-  subject { object.name }
-
-  let(:object)        { klass.new(name, handler, failure_chain) }
-  let(:klass)         { Class.new { include Processor::Fallible } }
-  let(:name)          { mock }
-  let(:handler)       { mock }
-  let(:failure_chain) { mock }
-
-  it { should be(name) }
-end

data/spec/unit/substation/processor/fallible/with_failure_chain_spec.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Fallible, '#with_failure_chain' do
-  subject { object.with_failure_chain(chain) }
-
-  let(:object)        { klass.new(name, handler, failure_chain) }
-  let(:klass)         { Class.new { include Processor::Fallible } }
-  let(:name)          { mock }
-  let(:handler)       { mock }
-  let(:failure_chain) { mock }
-  let(:chain)         { mock }
-
-  let(:expected) { klass.new(name, handler, chain) }
-
-  it { should eql(expected) }
-end

data/spec/unit/substation/processor/incoming/result_spec.rb

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

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

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

data/spec/unit/substation/processor/outgoing/name_spec.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Outgoing, '#name' do
-  subject { object.name }
-
-  let(:object)  { klass.new(name, handler) }
-  let(:klass)   { Class.new { include Processor::Outgoing } }
-  let(:name)    { mock }
-  let(:handler) { mock }
-
-  it { should be(name) }
-end

data/spec/unit/substation/processor/outgoing/success_predicate_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Outgoing, '#success?' do
-  subject { object.success?(response) }
-
-  let(:object)   { klass.new(name, handler) }
-  let(:klass)    { Class.new { include Processor::Outgoing } }
-  let(:name)     { mock }
-  let(:handler)  { mock }
-  let(:response) { mock }
-
-  it { should be(true) }
-end

data/spec/unit/substation/processor/success_predicate_spec.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor, '#success?' do
-  subject { object.success?(response) }
-
-  let(:object)  { klass.new }
-  let(:klass)   { Class.new { include Processor } }
-
-  context 'with a successful response' do
-    let(:response) { mock(:success? => true) }
-
-    it { should be(true) }
-  end
-
-  context 'with a failure response' do
-    let(:response) { mock(:success? => false) }
-
-    it { should be(false) }
-  end
-end

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

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Processor::Transformer, '#call' do
-  subject { object.call(response) }
-
-  let(:object)         { described_class.new(processor_name, Spec::Transformer) }
-  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(:transformed) { Response::Success.new(request, data) }
-  let(:data)        { Spec::Transformer.call(response) }
-
-  it { should eql(transformed) }
-end

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

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

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

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Response, '#to_request' do
-
-  subject { object.to_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(:response) { Request.new(name, env, output) }
-
-  it { should eql(response) }
-end