batsir 0.3.7.1 → 0.4.0

data/spec/batsir/stage_worker_spec.rb

@@ -1,128 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "spec_helper" )
-
-describe Batsir::StageWorker do
-  it "can set a filter queue" do
-    Batsir::StageWorker.instance_methods.map{|m| m.to_s}.should include "filter_queue="
-  end
-
-  context "with respect to including the StageWorker module" do
-    before :all do
-      class TestWorker
-        def self.stage_name
-          @stage_name_called = true
-          "TestWorker"
-        end
-
-        def self.stage_name_called
-          @stage_name_called || false
-        end
-
-        def self.initialize_filter_queue
-          @initialization_count ||= 0
-          @initialization_count += 1
-        end
-
-        def self.initialization_count
-          @initialization_count
-        end
-
-        include Batsir::StageWorker
-      end
-    end
-
-    it "registers workers once they include the stage worker" do
-      Batsir::Registry.get("TestWorker").should == TestWorker
-    end
-
-    it "calls the queue initialization method" do
-      TestWorker.initialization_count.should == 1
-    end
-
-    it "calls the stage name class method to register itself under" do
-      TestWorker.stage_name_called.should be_true
-    end
-  end
-
-  context "with respect to executing" do
-    before :all do
-      class TestWorker
-        def self.stage_name
-          "TestWorker"
-        end
-
-        def self.intitialize_filter_queue
-          @initialization_count ||= 0
-          @initialization_count += 1
-        end
-
-        include Batsir::StageWorker
-      end
-
-      class TestNotifier
-        def notify(message)
-          @notify_count ||= 0
-          @notify_count += 1
-        end
-
-        def notify_count
-          @notify_count ||= 0
-        end
-      end
-    end
-
-    before :each do
-      chain = Batsir::Chain.new
-
-      stage_options = {
-        :chain => chain,
-      }
-      stage = Batsir::Stage.new(stage_options)
-
-      stage.add_filter SumFilter
-      stage.add_filter AverageFilter
-      stage.add_notifier( :notification_queue_1, {:queue => :somequeue} )
-      stage.add_notifier( :notification_queue_2 )
-    end
-
-    it "does not execute when no operation queue is set" do
-      stage_worker = TestWorker.new
-      stage_worker.execute({}).should be_false
-    end
-
-    it "executes all operations in the operation queue when an #execute message is received" do
-      filter_queue = Batsir::FilterQueue.new
-      filter_queue.add SumFilter.new
-      filter_queue.add AverageFilter.new
-
-      stage_worker = TestWorker.new
-      stage_worker.filter_queue = filter_queue
-
-      queue = stage_worker.filter_queue
-      queue.each do |filter|
-        filter.execute_count.should == 0
-      end
-
-      stage_worker.execute({}).should be_true
-
-      queue.each do |filter|
-        filter.execute_count.should == 1
-      end
-    end
-
-    it "calls #notify on all notifiers in the filter queue when an #execute message is received" do
-      filter_queue = Batsir::FilterQueue.new
-      filter_queue.add_notifier TestNotifier.new
-
-      stage_worker = TestWorker.new
-      stage_worker.filter_queue = filter_queue
-
-      notifier = filter_queue.notifiers.first
-      notifier.should_not be_nil
-      notifier.notify_count.should == 0
-
-      stage_worker.execute({}).should be_true
-
-      notifier.notify_count.should == 1
-    end
-  end
-end

data/spec/batsir/strategies/retry_strategy_spec.rb

@@ -1,58 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
-
-describe Batsir::Strategies::RetryStrategy do
-  let( :strategy_class ) {
-    Batsir::Strategies::RetryStrategy
-  }
-
-  before :all do
-    class MockError < RuntimeError; end
-
-    class MockRetryContext
-      attr_accessor :strategy
-
-      def initialize(failures, retries)
-        @total_iterations = 0
-        @failures = failures
-        @strategy = Batsir::Strategies::RetryStrategy.new(self, retries)
-      end
-
-      def execute(message)
-        if @total_iterations == @failures
-          return "test complete"
-        else
-          @total_iterations += 1
-          handle_error(message)
-        end
-      end
-
-      def handle_error(message)
-        @strategy.execute(message, MockError.new)
-      end
-    end
-
-    @context = MockRetryContext.new(2,2)
-  end
-
-  it 'stores the number of allowed retries' do
-    @context.strategy.retries.should == 2
-  end
-
-  it 'stores the retry attempts per message' do
-    @context.strategy.attempts.should == {}
-  end
-
-  it 'attempts to execute the given number of times' do
-    @context = MockRetryContext.new(3,3)
-    @context.strategy.log.level = Batsir::Logger::FATAL
-    @context.execute("test").should == "test complete"
-    @context.strategy.attempts.size.should == 0
-  end
-
-  it 'throws an error when all retry attempts have been used' do
-    @context = MockRetryContext.new(3,2)
-    @context.strategy.log.level = Batsir::Logger::FATAL
-    lambda{@context.execute("test")}.should raise_error Batsir::Errors::RetryStrategyFailed
-  end
-
-end

data/spec/batsir/strategies/strategy_spec.rb

@@ -1,28 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
-
-describe Batsir::Strategies::Strategy do
-  let( :strategy_class ) {
-    Batsir::Strategies::Strategy
-  }
-
-  class MockContext
-    def execute(message)
-    end
-  end
-
-  class DefunctMockContext; end
-
-  it 'has an #execute method' do
-    strategy_class.instance_methods.map{|im| im.to_s}.should include "execute"
-  end
-
-  it 'has an accessable context' do
-    c = MockContext.new
-    strategy_class.new(c).context.should == c
-  end
-
-  it 'detects an incorrect context object being passed' do
-    c = DefunctMockContext.new
-    lambda{strategy_class.new(c)}.should raise_error Batsir::Errors::ExecuteMethodNotImplementedError
-  end
-end

data/spec/batsir/support/bunny_mocks.rb

@@ -1,135 +0,0 @@
-module Bunny
-  def self.instance
-    @instance
-  end
-
-  def self.run(options = {})
-    @instance = BunnyInstance.new(options)
-    yield @instance
-  end
-
-  def self.new(options = {})
-    @instance = BunnyInstance.new(options)
-    @instance
-  end
-
-  class Consumer
-    def initialize(channel, queue, consumer_tag = 'test', no_ack = true, exclusive = false, arguments = {})
-      @channel = channel
-      @queue = queue
-    end
-  end
-
-  class BunnyInstance
-    attr_accessor :queues
-    attr_accessor :options
-    attr_accessor :channel
-    attr_accessor :exchange
-
-    def initialize(options = {})
-      @options = options
-      @queues = {}
-    end
-
-    def start
-      @channel = create_channel
-      self
-    end
-
-    def exchange(exchange = nil)
-      @exchange = BunnyExchange.new(self, exchange) if exchange
-      @exchange
-    end
-
-    def queue(queue, options = {})
-      @queues[queue] = BunnyQueue.new
-    end
-
-    def create_channel
-      self
-    end
-
-    def connection
-      self
-    end
-
-    def host
-      @options[:host]
-    end
-
-    def port
-      @options[:port]
-    end
-
-    def user
-      @options[:user]
-    end
-
-    def pass
-      @options[:pass]
-    end
-
-    def vhost
-      @options[:vhost]
-    end
-
-    def number
-      1
-    end
-  end
-
-  class BunnyExchange
-    attr_accessor :name
-    attr_accessor :key
-    attr_accessor :message
-    attr_accessor :channel
-
-    def initialize(channel, name)
-      @channel = channel
-      @name = name
-    end
-
-    def publish(message, options = {})
-      @key = options[:routing_key] || options[:key]
-      @message = message
-    end
-  end
-
-  class BunnyQueue
-    attr_accessor :arguments
-    attr_accessor :block
-    attr_accessor :bound_exchange
-    attr_accessor :bound_key
-    attr_accessor :consumer
-
-    def initialize
-      @bindings = []
-    end
-
-    def bind(exchange, options)
-      @bound_exchange = exchange
-
-      @bound_key = options[:routing_key] || options[:key]
-      @bindings << {:exchange => @bound_exchange.name, :routing_key => @bound_key}
-    end
-
-    def subscribe(*args, &block)
-      @arguments = *args
-      @block = block
-    end
-
-    def subscribe_with(consumer, opts = {:block => false})
-      @block ||= opts[:block]
-      @consumer = consumer
-      @consumer
-    end
-
-    def name
-      @bound_key
-    end
-
-    def channel
-      @bound_exchange.channel
-    end
-  end
-end

data/spec/batsir/support/mock_filters.rb

@@ -1,43 +0,0 @@
-module Batsir::MockBehavior
-  attr_accessor :execute_count
-  def initialize(options = {})
-    super
-    @execute_count = 0
-  end
-
-  def execute(message)
-    @execute_count += 1
-  end
-end
-
-class Batsir::MockFilter < Batsir::Filter
-  include Batsir::MockBehavior
-end
-
-class PersistenceFilter < Batsir::MockFilter
-end
-
-class SumFilter < Batsir::MockFilter
-end
-
-class AverageFilter < Batsir::MockFilter
-end
-
-class Batsir::RetrievalFilter
-  include Batsir::MockBehavior
-end
-
-class Batsir::MessagePrinter < Batsir::Filter
-  def execute(message)
-    puts "In #{self.class.to_s}#execute(#{message.inspect})"
-    puts message
-    message
-  end
-end
-
-class Batsir::MessageCreator < Batsir::Filter
-  def execute(message)
-    puts "In #{self.class.to_s}#execute(#{message.inspect})"
-    {:id => message}
-  end
-end

data/spec/batsir/transformers/field_transformer_spec.rb

@@ -1,73 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
-
-describe Batsir::Transformers::FieldTransformer do
-  let( :transformer_class ) do
-    Batsir::Transformers::FieldTransformer
-  end
-
-  it "accepts an options hash in its initializer" do
-    transformer_instance = transformer_class.new( {} )
-    transformer_instance.should_not be_nil
-    transformer_instance.should be_a transformer_class
-  end
-
-  it "can set a field mapping using the 'fields' option" do
-    field_mapping = {:foo => :bar}
-    transformer = transformer_class.new( :fields => field_mapping )
-    transformer.fields.should == field_mapping
-  end
-
-  it "uses the fields mapping given in an options hash to transform the message using #transform" do
-    field_mapping = {:foo => 'bar'}
-    transformer = transformer_class.new( :fields => field_mapping )
-
-    message = {'bar' => 123}
-    transformed_message = transformer.transform(message)
-    transformed_message.should have_key 'foo'
-    transformed_message.should_not have_key :foo
-    transformed_message.should_not have_key 'bar'
-    transformed_message['foo'].should == 123
-  end
-
-  it "can use symbols and string based keys and values all the same" do
-    field_mapping = {:foo => "bar", "john" => :doe}
-    transformer = transformer_class.new( :fields => field_mapping )
-
-    message = {:bar => "foo", "doe" => :john}
-    transformed_message = transformer.transform(message)
-    transformed_message['foo'].should == 'foo'
-    transformed_message['john'].should == :john
-  end
-
-  it "removes options not in the fields option when a fields option is given" do
-    field_mapping = {:foo => :bar}
-    transformer = transformer_class.new( :fields => field_mapping )
-
-    message = {'bar' => "bar", 'john' => :doe}
-    transformed_message = transformer.transform(message)
-    transformed_message.should have_key 'foo'
-    transformed_message.should_not have_key 'bar'
-    transformed_message.should_not have_key 'john'
-  end
-
-  it "does not remove fields when no mapping is given, but enforces the no_symbol_keys principle" do
-    transformer = transformer_class.new
-
-    message = {:bar => "bar", :john => :doe}
-    transformed_message = transformer.transform(message)
-    transformed_message.should have_key :bar
-    transformed_message.should have_key :john
-  end
-
-  it "correctly handles more complex field mapping" do
-    field_mapping = {:id => :old_id}
-    transformer = transformer_class.new( :fields => field_mapping )
-
-    message = {:id => 2, :old_id => 1, :john => :doe}
-    transformed_message = transformer.transform(message)
-
-    transformed_message.should have_key 'id'
-    transformed_message.should_not have_key 'old_id'
-    transformed_message.should_not have_key 'john'
-  end
-end

data/spec/batsir/transformers/json_input_transformer_spec.rb

@@ -1,27 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "..", "spec_helper" )
-
-describe Batsir::Transformers::JSONInputTransformer do
-  it "is a Batsir::Transformers::Transformer" do
-    subject.should be_a Batsir::Transformers::Transformer
-  end
-
-  it "transforms the input to a ruby object" do
-    some_json = '{"foo" : "bar"}'
-    result = subject.transform(some_json)
-    result.should be_a Hash
-  end
-
-  it "transforms the input using string names" do
-    some_json = '{"foo" : "bar"}'
-    result = subject.transform(some_json)
-
-    result[:foo].should be_nil
-    result["foo"].should_not be_nil
-    result["foo"].should == "bar"
-  end
-
-  it "should throw a TransformError when the input is malformed" do
-    test = Batsir::Transformers::JSONInputTransformer.new
-    expect{ test.transform("1") }.to raise_error Batsir::Errors::TransformError
-  end
-end

data/spec/batsir/transformers/json_output_transformer_spec.rb

@@ -1,18 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "..", "spec_helper" )
-
-describe Batsir::Transformers::JSONOutputTransformer do
-  it "is a Batsir::Transformers::Transformer" do
-    subject.should be_a Batsir::Transformers::Transformer
-  end
-
-  it "transforms a hash to a valid json hash" do
-    some_hash = {:foo => :bar}
-    some_hash.should be_a Hash
-
-    result = subject.transform(some_hash)
-    result.should be_a String
-
-    result2 = JSON.parse(result)
-    result2.should be_a Hash
-  end
-end

data/spec/batsir/transformers/transformer_spec.rb

@@ -1,36 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
-
-describe Batsir::Transformers::Transformer do
-  let( :transformer_class ) do
-    Batsir::Transformers::Transformer
-  end
-
-  it "accepts an options hash in its initialiser" do
-    transformer_instance = transformer_class.new( {} )
-    transformer_instance.should_not be_nil
-    transformer_instance.should be_a transformer_class
-  end
-
-  it "has a #transform method" do
-    transformer_class.instance_methods.map{|m| m.to_s}.should include "transform"
-  end
-
-  it "has an #execute method" do
-    transformer_class.instance_methods.map{|m| m.to_s}.should include "execute"
-  end
-
-  it 'raises an error when the #execute method is not implemented' do
-    message = {:foo => :bar}
-    lambda{transformer_class.new.transform(message)}.should raise_error NotImplementedError
-  end
-
-  it "can transform the message" do
-    class Autobot < Batsir::Transformers::Transformer
-      def execute(message)
-        message = "transform"
-      end
-    end
-    message = {:foo => :bar}
-    Autobot.new.transform(message).should == "transform"
-  end
-end

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rspec/core'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require 'batsir'
-require 'batsir/support/mock_filters'
-require 'batsir/support/bunny_mocks'
-Celluloid.logger.level = Logger::ERROR
-RSpec.configure do |config|
-  config.before(:each) do
-    Celluloid.boot
-  end
-#  config.after(:each) do
-#    Celluloid.shutdown
-#  end
-end