substation 0.0.10.beta2 → 0.0.10

data/spec/spec_helper.rb

@@ -1,6 +1,29 @@
-require 'devtools/spec_helper'
+# encoding: utf-8
+
+require 'rspec/its'
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
 
-require 'concord' # makes spec setup easier
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name     'spec:unit'
+    add_filter       'config'
+    add_filter       'spec'
+    minimum_coverage 99.6
+  end
+end
+
+require 'substation'
+
+# MUST happen after ice_nine
+# got required by substation
+require 'devtools/spec_helper'
 
 module Spec
 
@@ -28,13 +51,25 @@ module Spec
   end
 
   class Processor
-    include Concord::Public.new(:env, :handler)
+    include Substation::Processor::Incoming
+
+    attr_reader :name
+
+    def call(request)
+      request.success(execute(request))
+    end
   end
 
   class Presenter
     include Concord.new(:data)
   end
 
+  class Transformer
+    def self.call(response)
+      :transformed
+    end
+  end
+
   module Handler
 
     class Evaluator
@@ -76,32 +111,26 @@ module Spec
 
   end
 
-  FAKE_HANDLER   = Object.new
-  FAKE_ENV       = Object.new
-  FAKE_PROCESSOR = Processor.new(FAKE_ENV, FAKE_HANDLER)
+  FAKE_ENV     = Object.new
+  FAKE_HANDLER = Object.new
 
-end
+  FAKE_CONFIG = Substation::Processor::Config.new(
+    Substation::Processor::Executor::NULL,
+    Substation::Chain::EMPTY,
+    Substation::EMPTY_ARRAY
+  )
 
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-  require 'coveralls'
+  FAKE_PROCESSOR = Processor.new(:test, FAKE_HANDLER, FAKE_CONFIG)
 
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-
-  SimpleCov.start do
-    command_name     'spec:unit'
-    add_filter       'config'
-    add_filter       'spec'
-    minimum_coverage 100
-  end
 end
 
-require 'substation'
-
 include Substation
 
 RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = :expect
+  end
 end

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

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::Definition do
+
+  subject { described_class.new(nil, []) }
+
+  it { should be_kind_of(Enumerable) }
+
+  let(:object)     { described_class.new(chain_name, processors) }
+  let(:chain_name) { double('chain_name') }
+
+  describe '#initialize' do
+    let(:chain_name) { 'chain name' }
+    let(:processors) { [Object.new, Object.new] }
+
+    it 'assigns the name' do
+      expect(object.name).to eq('chain name')
+    end
+
+    it 'has given processors' do
+      expect(object.each.count).to be(2)
+    end
+  end
+
+  describe '#each' do
+    subject { object.each(&block) }
+
+    let(:processors) { [ processor ] }
+    let(:processor)  { double('processor', :name => name) }
+    let(:name)       { double('name') }
+    let(:block)      { ->(_) { } }
+
+    it_should_behave_like 'an #each method'
+
+    it 'yields all processors' do
+      expect { |block| object.each(&block) }.to yield_successive_args(processor)
+    end
+  end
+
+  describe '#<<' do
+    subject { object << processor }
+
+    let(:processor)  { double('processor', :name => name) }
+    let(:name)       { double('name') }
+
+    context 'when the given processor is not currently present in object' do
+      let(:processors) { [] }
+
+      it 'registers the processor' do
+        expect(subject.each).to include(processor)
+      end
+
+      it_behaves_like 'a command method'
+    end
+
+    context 'when the given processor is already present in object' do
+      let(:processors) { [processor] }
+      let(:msg)        { Chain::Definition::DUPLICATE_PROCESSOR_MSG % [processor].inspect }
+
+      it 'raises DuplicateProcessorError' do
+        expect { subject }.to raise_error(DuplicateProcessorError, msg)
+      end
+    end
+  end
+
+  describe '#prepend' do
+    subject { object.prepend(other) }
+
+    let(:object)      { described_class.new(name, [processor_1]) }
+    let(:name)        { double('chain_name') }
+    let(:processor_1) { double('processor_1', :name => name_1) }
+    let(:name_1)      { double('name_1') }
+    let(:other_name)  { double('other_chain_name') }
+    let(:other)       { described_class.new(other_name, [processor_2]) }
+    let(:name_2)      { double('name_2') }
+
+    context 'and the processors are disjoint' do
+      let(:processor_2) { double('processor_2', :name => name_2) }
+
+      it { should eql(described_class.new(name, [processor_2, processor_1])) }
+    end
+
+    context 'and the processors contain duplicates' do
+      let(:processor_2) { processor_1 }
+      let(:msg)         { Chain::Definition::DUPLICATE_PROCESSOR_MSG % [processor_2].inspect }
+
+      it 'raises DuplicateProcessorError' do
+        expect { subject }.to raise_error(DuplicateProcessorError, msg)
+      end
+    end
+  end
+
+  describe '#replace_failure_chain' do
+    subject { object.replace_failure_chain(name, failure_chain) }
+
+    let(:processor)          { double('processor', :name => name) }
+    let(:name)               { double('name') }
+    let(:other_processor)    { double('other_processor', :name => other_name) }
+    let(:other_name)         { double('other_name') }
+    let(:failure_chain)      { double('failure_chain') }
+    let(:replaced_processor) { double('replaced_processor') }
+
+    context 'when a processor is registered under the given name' do
+      before do
+        expect(processor).to receive(:with_failure_chain).with(failure_chain).and_return(replaced_processor)
+      end
+
+      context 'when one processor is registered under the given name' do
+        let(:processors) { [other_processor, processor] }
+
+        it 'replaces the processor with a new one' do
+          expect(subject.each).to include(replaced_processor)
+        end
+
+        it_behaves_like 'a command method'
+      end
+
+      context 'when more than one processor is registered under the given name' do
+        let(:processors)          { [other_processor, processor, same_name_processor] }
+        let(:same_name_processor) { double('same_name_processor', :name => name) }
+
+        it 'replaces the first processor with a new one' do
+          expect(subject.each).to include(replaced_processor)
+          expect(subject.each).to include(same_name_processor)
+        end
+
+        it_behaves_like 'a command method'
+      end
+    end
+
+    context 'when no processor is registered under the given name' do
+      let(:processors) { [] }
+
+      it 'raises an UnknownProcessorError' do
+        expect { subject }.to raise_error(UnknownProcessor, "No processor named #{name.inspect} is registered")
+      end
+    end
+  end
+end

data/spec/unit/substation/chain/dsl/config/dsl_module_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL::Config, '#dsl_module' do
+  subject { object.dsl_module }
+
+  let(:object)     { described_class.new(registry, dsl_module) }
+  let(:registry)   { double('registry') }
+  let(:dsl_module) { double('dsl_module') }
+
+  it { should be(dsl_module) }
+end

data/spec/unit/substation/chain/dsl/config/registry_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL::Config, '#registry' do
+  subject { object.registry }
+
+  let(:object)     { described_class.new(registry, dsl_module) }
+  let(:registry)   { double('registry') }
+  let(:dsl_module) { double('dsl_module') }
+
+  it { should be(registry) }
+end

data/spec/unit/substation/chain/dsl/config_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL::Config, '.build' do
+  subject { described_class.build(registry) }
+
+  let(:registry)   { double('registry') }
+  let(:dsl_module) { double('dsl_module') }
+  let(:config)     { double('config') }
+
+  before do
+    expect(Chain::DSL::ModuleBuilder).to receive(:call).with(registry).and_return(dsl_module)
+    expect(described_class).to receive(:new).with(registry, dsl_module).and_return(config)
+  end
+
+  it { should eql(config) }
+end

data/spec/unit/substation/chain/dsl/module_builder_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL::ModuleBuilder do
+  describe '#dsl_module' do
+    subject { object.dsl_module }
+
+    let(:object)            { described_class.new(registry) }
+    let(:registry)          { { :test => processor_builder } }
+    let(:processor_builder) { double('processor_builder') }
+    let(:handler)           { double('handler') }
+    let(:failure_chain)     { double('failure_chain') }
+    let(:observers)         { EMPTY_ARRAY }
+
+    let(:definition)  { Chain::Definition.new(name, processors) }
+    let(:name)        { double('chain_name') }
+    let(:processors)  { [processor_1] }
+    let(:processor_1) { double('processor_1', :name => :processor_1) }
+    let(:processor_2) { double('processor_2', :name => :processor_2) }
+
+    before do
+      expect(processor_builder)
+        .to receive(:call)
+        .with(handler, failure_chain, observers)
+        .and_return(processor_2)
+    end
+
+    shared_examples_for 'Chain::DSL::ModuleBuilder#dsl_module' do
+      it 'compiles appropriate methods' do
+        config = Chain::DSL::Config.new(registry, subject)
+        dsl    = Chain::DSL.new(config, definition)
+
+        dsl.test(*dsl_method_args)
+
+        expect(dsl.definition).to include(processor_1)
+        expect(dsl.definition).to include(processor_2)
+      end
+    end
+
+    context 'when a failure_chain and observers are given' do
+      let(:dsl_method_args) { [handler, failure_chain, observers] }
+
+      it_behaves_like 'Chain::DSL::ModuleBuilder#dsl_module'
+    end
+
+    context 'when a failure_chain and no observers given' do
+      let(:dsl_method_args) { [handler, failure_chain] }
+
+      it_behaves_like 'Chain::DSL::ModuleBuilder#dsl_module'
+    end
+
+    context 'when no failure_chain and no observers are given' do
+      let(:dsl_method_args) { [handler] }
+      let(:failure_chain)   { Chain::EMPTY }
+
+      it_behaves_like 'Chain::DSL::ModuleBuilder#dsl_module'
+    end
+  end
+
+  describe '.call' do
+    subject { described_class.call(registry) }
+
+    let(:registry)          { { :test => processor_builder } }
+    let(:processor_builder) { double('processor_builder') }
+
+    let(:instance)   { double('module_builder', :dsl_module => dsl_module) }
+    let(:dsl_module) { double('dsl_module') }
+
+    before do
+      expect(described_class).to receive(:new).with(registry).and_return(instance)
+      expect(instance).to receive(:dsl_module).and_return(dsl_module)
+    end
+
+    it { should be(dsl_module) }
+  end
+end

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

@@ -0,0 +1,175 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL do
+  describe '#name' do
+    subject { chain_dsl.name }
+
+    include_context 'Chain::DSL#initialize'
+
+    it { should eql(chain_name) }
+  end
+
+  describe '#build' do
+    include_context 'Chain::DSL#initialize'
+
+    let(:failure_chain)       { Chain::EMPTY }
+    let(:block)               { ->(_) { test(Spec::FAKE_HANDLER) } }
+    let(:expected_definition) { Chain::Definition.new(new_chain_name, expected_processors) }
+    let(:expected)            { Chain.new(expected_definition, failure_chain) }
+
+    let(:new_processors)      { [new_processor] }
+    let(:new_processor)       { double('new_processor', :name => :new_processor) }
+
+    let(:new_chain_name)      { double('new_chain_name') }
+
+    shared_examples_for 'duplicate processors' do
+      let(:new_processor) { processor }
+      let(:msg)           { Chain::Definition::DUPLICATE_PROCESSOR_MSG % [processor].inspect }
+
+      it 'should raise DuplicateProcessorError' do
+        expect { subject }.to raise_error(DuplicateProcessorError, msg)
+      end
+    end
+
+    shared_examples_for 'disjoint processors' do
+      it { should eql(expected) }
+
+      it 'injects the proper registry' do
+        expect(chain_dsl.registry).to be(registry)
+      end
+    end
+
+    context 'when a block is given' do
+      subject { chain_dsl.build(new_chain_name, new_processors, failure_chain, &block) }
+
+      context 'and all processors are disjoint' do
+        let(:expected_processors) { [processor, new_processor, Spec::FAKE_PROCESSOR] }
+
+        it_behaves_like 'disjoint processors'
+      end
+
+      context 'and there are duplicate processors' do
+        it_behaves_like 'duplicate processors'
+      end
+    end
+
+    context 'when no block is given' do
+      subject { chain_dsl.build(new_chain_name, new_processors, failure_chain) }
+
+      context 'and all processors are disjoint' do
+        let(:expected_processors) { [processor, new_processor] }
+
+        it_behaves_like 'disjoint processors'
+      end
+
+      context 'and there are duplicate processors' do
+        it_behaves_like 'duplicate processors'
+      end
+    end
+  end
+
+  describe '#chain' do
+    include_context 'Chain::DSL#initialize'
+
+    let(:other_processor)     { double('other_processor', :name => :other_processor) }
+    let(:expected_definition) { Chain::Definition.new(chain_name, expected_processors) }
+    let(:expected)            { described_class.build(registry, expected_definition) }
+
+    context 'when no block is given' do
+      subject { chain_dsl.chain([other_processor]) }
+
+      let(:expected_processors) { [processor, other_processor] }
+
+      it { should eql(expected) }
+    end
+
+    context 'when block is given' do
+      subject { chain_dsl.chain([other_processor], &block) }
+
+      let(:block) { ->(_) { test(Spec::FAKE_HANDLER) } }
+
+      let(:expected_processors) { [processor, other_processor, Spec::FAKE_PROCESSOR] }
+
+      it { should eql(expected) }
+    end
+  end
+
+  describe '#nest' do
+    subject { object.nest(nested_name, chain_to_nest, executor) }
+
+    include_context 'Chain::DSL#initialize'
+
+    let(:object) { chain_dsl }
+
+    let(:chain_to_nest) { double('chain to nest') }
+    let(:nested_name)   { double('nested name', :to_sym => 'neste name') }
+    let(:executor)      { double }
+
+    let(:config)        { Processor::Config.new(executor, EMPTY_ARRAY, EMPTY_ARRAY) }
+    let(:expected)      { Processor::Nest::Incoming.new(nested_name, chain_to_nest, config) }
+
+    it { should eql(expected) }
+
+    it 'adds the chain to the definition' do
+      subject
+      expect(object.definition).to include(subject)
+    end
+  end
+
+  describe '#definition' do
+    subject { object.definition }
+
+    include_context 'Chain::DSL#initialize'
+
+    let(:object) { chain_dsl }
+
+    it { should eql(definition) }
+  end
+
+  describe '#failure_chain' do
+    subject { object.failure_chain(name, failure_chain) }
+
+    let(:object)        { described_class.new(config, definition) }
+    let(:config)        { Chain::DSL::Config.new(registry, dsl_module) }
+    let(:registry)      { double('registry') }
+    let(:dsl_module)    { Module.new }
+    let(:definition)    { double('definition', :name => double('chain_name')) }
+    let(:name)          { double('name') }
+    let(:failure_chain) { double('failure_chain') }
+
+    before do
+      expect(definition).to receive(:replace_failure_chain).with(name, failure_chain)
+    end
+
+    it_behaves_like 'a command method'
+  end
+
+  describe '.build' do
+
+    let(:registry)   { double('registry') }
+    let(:dsl)        { double('dsl') }
+    let(:config)     { double('config') }
+    let(:definition) { double('definition') }
+
+    before do
+      expect(Chain::DSL::Config).to receive(:build).with(registry).and_return(config)
+      expect(described_class).to receive(:new).with(config, definition).and_return(dsl)
+    end
+
+    context 'when a definition is given' do
+      subject { described_class.build(registry, definition) }
+
+      it { should be(dsl) }
+    end
+
+    context 'when no definition is given' do
+      subject { described_class.build(registry) }
+
+      let(:definition) { Chain::Definition::EMPTY }
+
+      it { should be(dsl) }
+    end
+  end
+end