batsir 0.1.0

data/spec/batsir/stage_worker_spec.rb

@@ -0,0 +1,128 @@
+require File.join( File.dirname(__FILE__), "..", "spec_helper" )
+
+describe Batsir::StageWorker do
+  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 "should register workers once they include the stage worker" do
+      Batsir::Registry.get("TestWorker").should == TestWorker
+    end
+
+    it "should call the queue initialization method" do
+      TestWorker.initialization_count.should == 1
+    end
+
+    it "should call the stage name class method to register itself under" do
+      TestWorker.stage_name_called.should be_true
+    end
+  end
+
+  it "should be possible to set an filter queue" do
+    Batsir::StageWorker.instance_methods.map{|m| m.to_s}.should include "filter_queue="
+  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 "should not execute when no operation queue is set" do
+      stage_worker = TestWorker.new
+      stage_worker.execute({}).should be_false
+    end
+
+    it "should execute 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 "should call #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/support/bunny_mocks.rb

@@ -0,0 +1,62 @@
+module Bunny
+  def self.instance
+    @instance
+  end
+
+  def self.run(options = {})
+    @instance = BunnyInstance.new(options)
+    yield @instance
+  end
+
+  class BunnyInstance
+    attr_accessor :queues
+    attr_accessor :options
+    attr_accessor :exchange
+
+    def initialize(options = {})
+      @options = options
+      @queues = {}
+    end
+
+    def exchange(exchange = nil)
+      @exchange = BunnyExchange.new(exchange) if exchange
+      @exchange
+    end
+
+    def queue(queue)
+      @queues[queue] = BunnyQueue.new
+    end
+  end
+
+  class BunnyExchange
+    attr_accessor :name
+    attr_accessor :key
+    attr_accessor :message
+
+    def initialize(name)
+      @name = name
+    end
+
+    def publish(message, options = {})
+      @key = options[:key]
+      @message = message
+    end
+  end
+
+  class BunnyQueue
+    attr_accessor :arguments
+    attr_accessor :block
+    attr_accessor :bound_exchange
+    attr_accessor :bound_key
+
+    def bind(exchange, options)
+      @bound_exchange = exchange
+      @bound_key = options[:key]
+    end
+
+    def subscribe(*args, &block)
+      @arguments = *args
+      @block = block
+    end
+  end
+end

data/spec/batsir/support/mock_filters.rb

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

@@ -0,0 +1,73 @@
+require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+
+describe Batsir::Transformers::FieldTransformer do
+  let( :transformer_class ) do
+    Batsir::Transformers::FieldTransformer
+  end
+
+  it "should accept 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 "should be possible to 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 "should use 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 => "bar"}
+    transformed_message = transformer.transform(message)
+    transformed_message.should have_key :foo
+    transformed_message.should_not have_key :bar
+    transformed_message[:foo].should == "bar"
+  end
+
+  it "should be possible to 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 "should remove 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 "should not remove fields when no mapping is given" 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 "should correctly handle 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

@@ -0,0 +1,22 @@
+require File.join( File.dirname(__FILE__), "..", "..", "spec_helper" )
+
+describe Batsir::Transformers::JSONInputTransformer do
+  it "should be a Batsir::Transformers::Transformer" do
+    subject.should be_a Batsir::Transformers::Transformer
+  end
+
+  it "should transform the input to a ruby object" do
+    some_json = '{"foo" : "bar"}'
+    result = subject.transform(some_json)
+    result.should be_a Hash
+  end
+
+  it "should transform 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
+end

data/spec/batsir/transformers/json_output_transformer_spec.rb

@@ -0,0 +1,18 @@
+require File.join( File.dirname(__FILE__), "..", "..", "spec_helper" )
+
+describe Batsir::Transformers::JSONOutputTransformer do
+  it "should be a Batsir::Transformers::Transformer" do
+    subject.should be_a Batsir::Transformers::Transformer
+  end
+
+  it "should transform 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

@@ -0,0 +1,22 @@
+require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+
+describe Batsir::Transformers::Transformer do
+  let( :transformer_class ) do
+    Batsir::Transformers::Transformer
+  end
+
+  it "should accept 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 "should have a #transform method" do
+    transformer_class.instance_methods.map{|m| m.to_s}.should include "transform"
+  end
+
+  it "should return the message by default" do
+    message = {:foo => :bar}
+    transformer_class.new.transform(message).should == message
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+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.after(:each) do
+    Celluloid.shutdown
+  end
+end

metadata

@@ -0,0 +1,220 @@
+--- !ruby/object:Gem::Specification
+name: batsir
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- J.W. Koelewijn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: blockenspiel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "Batsir uses so called stages to define operation queues. These operation
+  queus\n consist of several operations that will be executed one after the other.
+  Each stage\n is defined by its name and the queue on which it will listen. Once
+  a message is received\n on the queue, it is dispatched to a worker in a seperate
+  thread that will pass the message\n to each operation in the operation queue.\n
+  Operation queues can have 4 different operations, 1 common operation type, and 3
+  special \n purpose operations: retrieval operations (which are always executed before
+  all other operations),\n persistence operations (which are always executed after
+  the common operations, but before the\n notification operations) and notification
+  operations (which will always be executed last)\n This makes it possible to create
+  chains of stages to perform tasks that depend on each\n other, but otherwise have
+  a low coupling"
+email: jwkoelewijn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- batsir.gemspec
+- batsir.png
+- lib/batsir.rb
+- lib/batsir/acceptors/acceptor.rb
+- lib/batsir/acceptors/amqp_acceptor.rb
+- lib/batsir/amqp.rb
+- lib/batsir/chain.rb
+- lib/batsir/config.rb
+- lib/batsir/dsl/dsl_mappings.rb
+- lib/batsir/filter.rb
+- lib/batsir/filter_queue.rb
+- lib/batsir/logo.rb
+- lib/batsir/notifiers/amqp_notifier.rb
+- lib/batsir/notifiers/notifier.rb
+- lib/batsir/registry.rb
+- lib/batsir/stage.rb
+- lib/batsir/stage_worker.rb
+- lib/batsir/transformers/field_transformer.rb
+- lib/batsir/transformers/json_input_transformer.rb
+- lib/batsir/transformers/json_output_transformer.rb
+- lib/batsir/transformers/transformer.rb
+- spec/batsir/acceptors/acceptor_spec.rb
+- spec/batsir/acceptors/amqp_acceptor_spec.rb
+- spec/batsir/chain_spec.rb
+- spec/batsir/dsl/chain_mapping_spec.rb
+- spec/batsir/dsl/stage_mapping_spec.rb
+- spec/batsir/filter_queue_spec.rb
+- spec/batsir/filter_spec.rb
+- spec/batsir/notifiers/amqp_notifier_spec.rb
+- spec/batsir/notifiers/notifier_spec.rb
+- spec/batsir/stage_spec.rb
+- spec/batsir/stage_worker_spec.rb
+- spec/batsir/support/bunny_mocks.rb
+- spec/batsir/support/mock_filters.rb
+- spec/batsir/transformers/field_transformer_spec.rb
+- spec/batsir/transformers/json_input_transformer_spec.rb
+- spec/batsir/transformers/json_output_transformer_spec.rb
+- spec/batsir/transformers/transformer_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/jwkoelewijn/batsir
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1524934688976294279
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: Batsir is an execution platform for stage based operation queue execution
+test_files: []