substation 0.0.10.beta2 → 0.0.10

data/spec/unit/substation/environment/dsl_spec.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Substation::Environment::DSL do
+  describe '.registry' do
+    context 'when a block is given' do
+      let(:expected) {
+        DSL::Registry.new(guard, {
+          :test => Processor::Builder.new(:test, Spec::Processor, Processor::Executor::NULL)
+        })
+      }
+
+      let(:block) { ->(_) { register :test, Spec::Processor } }
+
+      let(:processor_name) { :test }
+      let(:registry)       { Hash.new }
+
+      context 'and no guard is given' do
+        subject { described_class.registry(&block) }
+
+        let(:guard) { described_class::GUARD }
+
+        it { should eql(expected) }
+      end
+
+      context 'and a guard is given' do
+        subject { described_class.registry(guard, &block) }
+
+        let(:guard) { double('guard') }
+
+        # FIXME: this expectation should also be specified in the above
+        # context but since Guard includes Adamantium::Flat, setting a
+        # method expectation on it doesn't work
+        before do
+          expect(guard).to receive(:call).with(processor_name, registry)
+        end
+
+        it { should eql(expected) }
+      end
+    end
+
+    context 'when no block is given' do
+      subject { described_class.registry }
+
+      let(:expected) { DSL::Registry.new(guard) }
+
+      context 'and no guard is given' do
+        subject { described_class.registry }
+
+        let(:guard) { described_class::GUARD }
+
+        it { should eql(expected) }
+      end
+
+      context 'and a guard is given' do
+        subject { described_class.registry(guard) }
+
+        let(:guard) { double('guard') }
+
+        # FIXME: this expectation should also be specified in the above
+        # context but since Guard includes Adamantium::Flat, setting a
+        # method expectation on it doesn't work
+        before do
+          expect(guard).to_not receive(:call)
+        end
+
+        it { should eql(expected) }
+      end
+    end
+  end
+
+  describe '#register' do
+    subject { object.register(name, processor) }
+
+    let(:object)    { described_class.new(registry) }
+    let(:registry)  { DSL::Registry.new(guard) }
+    let(:guard)     { described_class::GUARD }
+    let(:processor) { Spec::Processor }
+
+    let(:expected) {
+      DSL::Registry.new(guard, {
+        :test => Processor::Builder.new(:test, Spec::Processor, Processor::Executor::NULL)
+      })
+    }
+
+    context 'when the given name is valid' do
+
+      shared_examples 'name is valid' do
+        its(:registry) { should eql(expected) }
+
+        it_behaves_like 'a command method'
+      end
+
+      context 'and the name is given as a Symbol' do
+        it_behaves_like 'name is valid' do
+          let(:name) { :test }
+        end
+      end
+
+      context 'and the name is given as a String' do
+        it_behaves_like 'name is valid' do
+          let(:name) { 'test' }
+        end
+      end
+
+    end
+
+    context 'when the given name is reserved' do
+      let(:name) { Chain::DSL::BASE_METHODS.first }
+      let(:msg)  { DSL::Guard::RESERVED_NAME_MSG % name.inspect }
+
+      it 'raises ReservedNameError' do
+        expect { subject }.to raise_error(ReservedNameError, msg)
+      end
+    end
+
+    context 'when the given name is already registered' do
+      let(:name) { :test }
+      let(:msg)  { DSL::Guard::ALREADY_REGISTERED_MSG % name.inspect }
+
+      before do
+        object.register(name, processor)
+      end
+
+      it 'raises ReservedNameError' do
+        expect { subject }.to raise_error(AlreadyRegisteredError, msg)
+      end
+    end
+  end
+
+  describe '#registry' do
+    subject { object.registry }
+
+    let(:registry) { DSL::Registry.new(guard) }
+    let(:guard)    { described_class::GUARD }
+
+    context 'when a block is given' do
+      let(:object)   { described_class.new(registry, &block) }
+      let(:block)    { ->(_) { register :test, Spec::Processor } }
+      let(:expected) {
+        DSL::Registry.new(guard, {
+          :test => Processor::Builder.new(:test, Spec::Processor, Processor::Executor::NULL)
+        })
+      }
+
+      it { should eql(expected) }
+    end
+
+    context 'when no block is given' do
+      let(:object) { described_class.new(registry) }
+
+      it { should eql(registry) }
+    end
+  end
+end

data/spec/unit/substation/environment_spec.rb

@@ -0,0 +1,259 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Environment do
+  let(:object)   { described_class.new(app_env, actions, chain_dsl) }
+  let(:app_env)  { double('app_env') }
+  let(:actions)  { Dispatcher.new_registry }
+  let(:registry) { double('registry') }
+
+  describe '#actions' do
+    subject { object.actions }
+
+    let(:chain_dsl) { double('app_env', :registry => registry) }
+
+    it { should be(actions) }
+  end
+
+  describe '#app_env' do
+    subject { object.app_env }
+
+    let(:chain_dsl) { double('app_env', :registry => registry) }
+
+    it { should be(app_env) }
+  end
+
+  describe '#chain' do
+    let(:chain_dsl) { Chain::DSL.build(registry) }
+    let(:registry)  { described_class::DSL.registry(&r_block) }
+    let(:r_block)   { ->(_) { register(:test, Spec::Processor) } }
+
+    let(:other)         { double('other', :each => EMPTY_ARRAY) }
+    let(:failure_chain) { double('failure_chain') }
+    let(:block)         { ->(_) { test Spec::FAKE_HANDLER, Chain::EMPTY } }
+
+    let(:name)     { double('name') }
+
+    context 'when other, failure_chain and block are given' do
+      subject { object.chain(name, other, failure_chain, &block) }
+
+      it { should eql(chain_dsl.build(name, other, failure_chain, &block)) }
+    end
+
+    context 'when other, failure_chain and no block are given' do
+      subject { object.chain(name, other, failure_chain) }
+
+      it { should eql(chain_dsl.build(name, other, failure_chain)) }
+    end
+
+    context 'when other, no failure_chain and no block are given' do
+      subject { object.chain(name, other) }
+
+      it { should eql(chain_dsl.build(name, other, Chain::EMPTY)) }
+    end
+
+    context 'when no parameters are given' do
+      subject { object.chain }
+
+      it { should eql(chain_dsl.build(nil, Chain::EMPTY, Chain::EMPTY)) }
+    end
+  end
+
+  describe '#dispatcher' do
+    subject { object.dispatcher }
+
+    let(:chain_dsl)   { double('chain_dsl', :registry => registry) }
+
+    let(:expected)    { Dispatcher.new(actions, app_env) }
+
+    it { should eql(expected) }
+  end
+
+  describe '#[]' do
+    subject { object[name] }
+
+    let(:name)      { double('name', :to_sym => :test) }
+    let(:chain_dsl) { Chain::DSL.build(described_class::DSL.registry(&block)) }
+    let(:block)     { ->(_) { register(:test, Spec::Processor) } }
+
+    let(:chain)         { chain_dsl.build(name, other, failure_chain, &chain_block) }
+    let(:other)         { Chain::EMPTY }
+    let(:failure_chain) { Chain::EMPTY }
+    let(:chain_block)   { ->(_) { test(Spec::FAKE_HANDLER) } }
+
+    context 'when a chain is registered under name' do
+      before do
+        object.register(name, &chain_block)
+      end
+
+      it { should eql(chain) }
+    end
+
+    context 'when no chain is registered under name' do
+      it 'raises an error' do
+        expect { subject }.to raise_error(KeyError)
+      end
+    end
+  end
+
+  describe 'equalizer behavior' do
+    subject { object == other }
+
+
+    let(:chain_dsl) { double('chain_dsl', :registry => registry) }
+
+    let(:other)  { described_class.new(app_env, actions, other_chain_dsl) }
+    let(:other_chain_dsl) {
+      double('other_chain_dsl', :registry => other_registry)
+    }
+
+    context 'with an equal registry' do
+      let(:other_registry) { registry }
+
+      it { should be(true) }
+    end
+
+    context 'with a different registry' do
+      let(:other_registry) { double('other_registry') }
+
+      it { should be(false) }
+    end
+  end
+
+  describe '#inherit' do
+
+    let(:chain_dsl) { Chain::DSL.build(described_class::DSL.registry(&env_block)) }
+    let(:env_block) {
+      ->(_) {
+        register(:test_1, Spec::Processor)
+        register(:test_2, Spec::Processor)
+      }
+    }
+
+    let(:expected)  { described_class.build(app_env, actions, &expected_block) }
+
+    let(:expected_block) {
+      ->(_) {
+        register(:test_1, Spec::Processor)
+        register(:test_2, Spec::Processor)
+        register(:test_3, Spec::Processor)
+      }
+    }
+
+    let(:block) {
+      ->(_) {
+        register(:test_3, Spec::Processor)
+      }
+    }
+
+    context 'when no app_env and actions are given' do
+      subject { object.inherit(&block) }
+
+      let(:new_actions) { Dispatcher.new_registry }
+
+      it { should eql(expected) }
+
+      its(:app_env) { should eql(app_env) }
+      its(:actions) { should eql(new_actions) }
+    end
+
+    context 'when app_env is given' do
+      subject { object.inherit(new_app_env, &block) }
+
+      let(:expected)    { described_class.build(new_app_env, actions, &expected_block) }
+      let(:new_app_env) { double('new_app_env') }
+      let(:new_actions) { Dispatcher.new_registry }
+
+      it { should eql(expected) }
+
+      its(:app_env) { should eql(new_app_env) }
+      its(:actions) { should eql(new_actions) }
+    end
+
+    context 'when app_env and actions are given' do
+      subject { object.inherit(app_env, new_actions, &block) }
+
+      let(:new_actions) { double('new_actions') }
+
+      it { should eql(expected) }
+
+      its(:app_env) { should eql(app_env) }
+      its(:actions) { should be(new_actions) }
+    end
+  end
+
+  describe '#register' do
+    let(:chain_dsl) { Chain::DSL.build(described_class::DSL.registry(&block)) }
+    let(:block)     { ->(_) { register(:test, Spec::Processor) } }
+
+    let(:chain_block) { ->(_) { test(Spec::FAKE_HANDLER) } }
+
+    let(:name)          { double('name', :to_sym => :test) }
+    let(:other)         { Chain::EMPTY }
+    let(:failure_chain) { double }
+
+    shared_examples 'Environment#register' do
+      it_behaves_like 'a command method'
+
+      it 'registers the chain under the given name' do
+        subject
+        expect(object[name]).to eql(chain)
+      end
+    end
+
+    context 'when other and failure_chain are not given' do
+      subject { object.register(name, &chain_block) }
+
+      let(:chain) { chain_dsl.build(name, Chain::EMPTY, Chain::EMPTY, &chain_block) }
+
+      it_behaves_like 'Environment#register'
+    end
+
+    context 'when other is given and failure_chain is not given' do
+      subject { object.register(name, other, &chain_block) }
+
+      let(:chain) { chain_dsl.build(name, other, Chain::EMPTY, &chain_block) }
+
+      it_behaves_like 'Environment#register'
+    end
+
+    context 'when both other and failure_chain are given' do
+      subject { object.register(name, other, failure_chain, &chain_block) }
+
+      let(:chain) { chain_dsl.build(name, other, failure_chain, &chain_block) }
+
+      it_behaves_like 'Environment#register'
+    end
+  end
+
+  describe '.build' do
+
+    let(:expected)  { described_class.new(app_env, actions, chain_dsl) }
+    let(:chain_dsl) { Chain::DSL.build(described_class::DSL.registry(&block)) }
+    let(:block)     { ->(_) { register(:test, Substation) } }
+
+    shared_examples 'Environment.build' do
+      it { should eql(expected) }
+
+      its(:app_env) { should be(app_env) }
+    end
+
+    context 'when no actions are given' do
+      subject { described_class.build(app_env, &block) }
+
+
+      it_behaves_like 'Environment.build'
+
+      its(:actions) { should eql(actions) }
+    end
+
+    context 'when actions are given' do
+      subject { described_class.build(app_env, actions, &block) }
+
+      it_behaves_like 'Environment.build'
+
+      its(:actions) { should be(actions) }
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Builder, '#call' do
+  subject { object.call(handler, failure_chain, observers) }
+
+  include_context 'Processor::Config#initialize'
+
+  let(:object)    { described_class.new(name, klass, executor) }
+  let(:handler)   { double('handler') }
+  let(:name)      { double('name') }
+  let(:klass)     { double('klass') }
+  let(:processor) { double('processor') }
+
+  before do
+    expect(klass).to receive(:new).with(name, handler, processor_config).and_return(processor)
+  end
+
+  it { should eql(processor) }
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Config do
+  describe '#executor' do
+    subject { processor_config.executor }
+
+    include_context 'Processor::Config#initialize'
+
+    it { should be(executor) }
+  end
+
+  describe '#failure_chain' do
+    subject { processor_config.failure_chain }
+
+    include_context 'Processor::Config#initialize'
+
+    it { should be(failure_chain) }
+  end
+
+  describe '#observers' do
+    subject { processor_config.observers }
+
+    include_context 'Processor::Config#initialize'
+
+    it { should be(observers) }
+  end
+
+  describe '#with_failure_chain' do
+    subject { processor_config.with_failure_chain(other_failure_chain) }
+
+    let(:other_failure_chain) { double('other failure chain') }
+    let(:object) { described_class.new(executor, other_failure_chain, observers) }
+
+    include_context 'Processor::Config#initialize'
+
+    it { should eql(object) }
+  end
+end