batsir 0.1.0

data/lib/batsir/stage_worker.rb

@@ -0,0 +1,86 @@
+require 'sidekiq'
+
+module Batsir
+  module StageWorker
+    attr_accessor :filter_queue
+
+    def self.included(base)
+      Registry.register(base.stage_name, base)
+      base.initialize_filter_queue
+    end
+
+    def perform(message)
+      execute(message)
+    end
+
+    def execute(message)
+      return false unless @filter_queue
+      @filter_queue.filters.each do |filter|
+        message = filter.execute(message)
+        return false if message.nil?
+      end
+      @filter_queue.notifiers.each do |notifier|
+        notifier.notify(message)
+      end
+      true
+    end
+
+    def self.compile_from(stage)
+      code = <<-EOF
+        class #{stage.name.capitalize.gsub(' ','')}Worker
+          def self.stage_name
+            "#{stage.name}"
+          end
+
+          def initialize
+            @filter_queue = self.class.filter_queue
+          end
+
+          def self.filter_queue
+            @filter_queue
+          end
+
+          def self.initialize_filter_queue
+            @filter_queue = Batsir::FilterQueue.new
+      EOF
+
+      stage.filter_declarations.each do |filter_declaration|
+        code << <<-EOF
+            @filter_queue.add #{filter_declaration.filter.to_s}.new(#{filter_declaration.options.to_s})
+        EOF
+      end
+
+      stage.notifiers.each do |notifier, options_set|
+        options_set.each do |options|
+          code << <<-EOF
+            notifier = #{notifier.to_s}.new(#{options.to_s})
+          EOF
+
+          if stage.notifier_transformers.any?
+            stage.notifier_transformers.each do |transformer_declaration|
+              code << <<-EOF
+            notifier.add_transformer #{transformer_declaration.transformer}.new(#{transformer_declaration.options.to_s})
+              EOF
+            end
+          else
+            code << <<-EOF
+            notifier.add_transformer Batsir::Transformers::JSONOutputTransformer.new
+            EOF
+          end
+          code << <<-EOF
+            @filter_queue.add_notifier notifier
+          EOF
+        end
+      end
+
+      code << <<-EOF
+          end
+
+          include Sidekiq::Worker
+          include Batsir::StageWorker
+        end
+      EOF
+      code
+    end
+  end
+end

data/lib/batsir/transformers/field_transformer.rb

@@ -0,0 +1,40 @@
+module Batsir
+  module Transformers
+    class FieldTransformer < Transformer
+      attr_accessor :fields
+
+      def fields
+        @fields ||= {}
+      end
+
+      def fields=(hash)
+        @fields = {}
+        hash.each do |k, v|
+          @fields[k.to_sym] = v.to_sym
+        end
+      end
+
+      def transform(message)
+        fields = self.fields
+        if fields.any? && message.respond_to?(:keys)
+          symbolized_message_keys = {}
+          message.keys.each do |key|
+            symbolized_message_keys[key.to_sym] = key
+          end
+
+          fields_to_remove = symbolized_message_keys.keys - fields.keys - fields.values
+
+          fields.each do |new, old|
+            message[new] = message.delete(symbolized_message_keys[old])
+          end
+
+          fields_to_remove.each do |field|
+            message.delete(symbolized_message_keys[field])
+          end
+        end
+        message
+      end
+
+    end
+  end
+end

data/lib/batsir/transformers/json_input_transformer.rb

@@ -0,0 +1,9 @@
+module Batsir
+  module Transformers
+    class JSONInputTransformer < Transformer
+      def transform(message)
+        JSON.parse(message, :symbolize_names => false)
+      end
+    end
+  end
+end

data/lib/batsir/transformers/json_output_transformer.rb

@@ -0,0 +1,9 @@
+module Batsir
+  module Transformers
+    class JSONOutputTransformer < Transformer
+      def transform(message)
+        JSON.dump(message)
+      end
+    end
+  end
+end

data/lib/batsir/transformers/transformer.rb

@@ -0,0 +1,15 @@
+module Batsir
+  module Transformers
+    class Transformer
+      def initialize(options = {})
+        options.each do |attr, value|
+          self.send("#{attr}=", value)
+        end
+      end
+
+      def transform(message)
+        message
+      end
+    end
+  end
+end

data/spec/batsir/acceptors/acceptor_spec.rb

@@ -0,0 +1,136 @@
+require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+
+describe Batsir::Acceptors::Acceptor do
+  let( :acceptor_class ) {
+    Batsir::Acceptors::Acceptor
+  }
+
+  it "should be a Celluloid actor" do
+    acceptor_class.ancestors.should include Celluloid
+  end
+
+  it "should be possible to set the stage name for the acceptor" do
+    acceptor = acceptor_class.new
+    stage_name = "some stage"
+    acceptor.stage_name = stage_name
+    acceptor.stage_name.should == stage_name
+  end
+
+  it "should have a #start method" do
+    acceptor_class.instance_methods.map{|im| im.to_s}.should include "start"
+  end
+
+  it "should have an #start_filter_chain method" do
+    acceptor_class.instance_methods.map{|im| im.to_s}.should include "start_filter_chain"
+  end
+
+  it "should be possible to initialize an Acceptor with on options hash" do
+    acceptor = acceptor_class.new({})
+    acceptor.should_not be_nil
+  end
+
+  it "should look up a worker class when the #start_filter_chain method is called" do
+    acceptor = acceptor_class.new
+    stage_name = "some stage"
+    acceptor.stage_name = stage_name
+    Batsir::Registry.should_receive(:get).with(stage_name)
+    acceptor.start_filter_chain({})
+  end
+
+  it "should have a transformer_queue" do
+    acceptor = acceptor_class.new
+    acceptor.transformer_queue.should_not be_nil
+  end
+
+  it "should initially have an empty transformer_queue" do
+    acceptor = acceptor_class.new
+    acceptor.transformer_queue.should_not be_nil
+    acceptor.transformer_queue.should be_empty
+  end
+
+  it "should be possible to add a transformer to the transformer_queue" do
+    transformer = :transformer
+
+    acceptor = acceptor_class.new
+    acceptor.add_transformer transformer
+
+    acceptor.transformer_queue.should_not be_empty
+    acceptor.transformer_queue.size.should == 1
+    acceptor.transformer_queue.first.should == :transformer
+  end
+
+  it "should be possible to add a transformer multiple times" do
+    transformer = :transformer
+
+    acceptor = acceptor_class.new
+    acceptor.add_transformer transformer
+    acceptor.add_transformer transformer
+
+    acceptor.transformer_queue.should_not be_empty
+    acceptor.transformer_queue.size.should == 2
+  end
+
+  it "should be possible to set a cancellator" do
+    cancellator = :cancel
+    acceptor = acceptor_class.new
+    acceptor.cancellator = cancellator
+    acceptor.cancellator.should == cancellator
+  end
+
+  it "should be possible to set a cancellator in the constructor using a hash" do
+    cancellator = :cancel
+    acceptor = acceptor_class.new(:cancellator => cancellator)
+    acceptor.cancellator.should == cancellator
+  end
+
+  it "should call the #perform_async on the worker class when #start_filter_chain is called" do
+    class MockWorker
+      def self.stage_name
+        "mock_stage"
+      end
+
+      def self.initialize_filter_queue
+      end
+
+      def self.perform_async(*args)
+      end
+
+      include Batsir::StageWorker
+    end
+
+    acceptor = acceptor_class.new
+    stage_name = "some stage"
+
+    acceptor.stage_name = stage_name
+
+    Batsir::Registry.register(stage_name, MockWorker)
+    MockWorker.should_receive(:perform_async)
+    acceptor.start_filter_chain({})
+  end
+
+  it "should call #transform on the acceptor transformers" do
+    class MockTransformer < Batsir::Transformers::Transformer
+      def transform(message)
+        @@transformed ||= 0
+        @@transformed += 1
+      end
+
+      def self.transformed
+        @@transformed ||= 0
+        @@transformed
+      end
+    end
+
+    acceptor = acceptor_class.new
+    stage_name = "some stage"
+
+    acceptor.stage_name = stage_name
+    acceptor.add_transformer MockTransformer.new
+
+    MockTransformer.transformed.should == 0
+
+    acceptor.start_filter_chain({})
+
+    MockTransformer.transformed.should == 1
+  end
+end

data/spec/batsir/acceptors/amqp_acceptor_spec.rb

@@ -0,0 +1,169 @@
+require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+
+describe Batsir::Acceptors::AMQPAcceptor do
+
+  let(:acceptor_class){
+    Batsir::Acceptors::AMQPAcceptor
+  }
+
+  context "With respect to setting options" do
+
+    it "should be a Batsir::Acceptors::Acceptor" do
+      acceptor_class.ancestors.should include Batsir::Acceptors::Acceptor
+    end
+
+    it "should be possible to set the queue on which to listen" do
+      acceptor = acceptor_class.new(:queue => :queue)
+      acceptor.queue.should == :queue
+    end
+
+    it "should be possible to set the host of the amqp broker" do
+      acceptor = acceptor_class.new(:host => 'localhost')
+      acceptor.host.should == 'localhost'
+    end
+
+    it "should be possible to set the port of the amqp broker" do
+      acceptor = acceptor_class.new(:port => 1234)
+      acceptor.port.should == 1234
+    end
+
+    it "should be possible to set the username with which to connect to the broker" do
+      acceptor = acceptor_class.new(:username => 'some_user')
+      acceptor.username.should == 'some_user'
+    end
+
+    it "should be possible to set the password with which to connect to the broker" do
+      acceptor = acceptor_class.new(:password => 'password')
+      acceptor.password.should == 'password'
+    end
+
+    it "should be possible to set the vhost to use on the broker" do
+      acceptor = acceptor_class.new(:vhost => '/vhost')
+      acceptor.vhost.should == '/vhost'
+    end
+
+    it "should be possible to set the exchange to use on the broker" do
+      acceptor = acceptor_class.new(:exchange => 'amq.direct')
+      acceptor.exchange.should == 'amq.direct'
+    end
+
+    it "should default to amqp://guest:guest@localhost:5672/ with direct exchange on vhost ''" do
+      acceptor = acceptor_class.new(:queue => :somequeue)
+      acceptor.queue.should    == :somequeue
+      acceptor.host.should     == 'localhost'
+      acceptor.port.should     == 5672
+      acceptor.username.should == 'guest'
+      acceptor.password.should == 'guest'
+      acceptor.vhost.should    == '/'
+      acceptor.exchange.should == 'amq.direct'
+    end
+  end
+
+  context "with respect to starting the acceptor" do
+    def new_acceptor(options = {})
+      acceptor_class.new(options)
+    end
+
+    it "should connect to the configured host" do
+      acceptor = new_acceptor(:host => 'somehost')
+      acceptor.start
+      instance = Bunny.instance
+      instance.options[:host].should == 'somehost'
+    end
+
+    it "should connect to the configured port" do
+      acceptor = new_acceptor(:port => 1234)
+      acceptor.start
+      instance = Bunny.instance
+      instance.options[:port].should == 1234
+    end
+
+    it "should connect with the configured username" do
+      acceptor = new_acceptor(:username => 'user')
+      acceptor.start
+      instance = Bunny.instance
+      instance.options[:user].should == 'user'
+    end
+
+    it "should connect with the configured password" do
+      acceptor = new_acceptor(:password => 'pass')
+      acceptor.start
+      instance = Bunny.instance
+      instance.options[:pass].should == 'pass'
+    end
+
+    it "should connect to the configured vhost" do
+      acceptor = new_acceptor(:vhost => '/vhost')
+      acceptor.start
+      instance = Bunny.instance
+      instance.options[:vhost].should == '/vhost'
+    end
+
+    it "should declare the configured exchange" do
+      acceptor = new_acceptor(:exchange => 'some_exchange')
+      acceptor.start
+      instance = Bunny.instance
+      instance.exchange.name.should == 'some_exchange'
+    end
+
+    it "should bind the configured exchange to the queue" do
+      acceptor = new_acceptor(:exchange => 'some_exchange', :queue => :queue)
+      acceptor.start
+      instance = Bunny.instance
+      queue = instance.queues[:queue]
+      queue.bound_exchange.name.should == 'some_exchange'
+      queue.bound_key.should == :queue
+    end
+
+    it "should start listening on the configured queue" do
+      acceptor = new_acceptor(:queue => :some_queue)
+      acceptor.start
+      instance = Bunny.instance
+      instance.queues.size.should == 1
+      instance.queues.keys.should include :some_queue
+    end
+
+    it "should initialize the subscription with the acceptor's cancellator" do
+      cancellator = :cancellator
+      acceptor = new_acceptor(:queue => :some_queue, :cancellator => cancellator)
+      acceptor.start
+      instance = Bunny.instance
+      puts instance.queues[:some_queue].arguments.first[:cancellator].should == cancellator
+    end
+
+    it "should call the #start_filter_chain method when a message is received" do
+      acceptor = new_acceptor(:queue => :some_queue)
+
+      # Because acceptor is a Celluloid Actor, it is not possible to define a method
+      # on the instance directly, because you actually hold a reference to a
+      # ActorProxy.
+      # Fortunately, ActorProxy defines the #_send_ method, which we can use to
+      # define a singleton_method on the actual proxied instance.
+      # We cannot just redefine the class method here, because it will break other
+      # tests.
+
+      start_filter_chain_mock_method = lambda do |message|
+        @method_called ||= 0
+        @method_called += 1
+      end
+
+      method_called_mock_method = lambda do
+        @method_called ||= 0
+      end
+
+      acceptor._send_(:define_singleton_method, :start_filter_chain, start_filter_chain_mock_method)
+      acceptor._send_(:define_singleton_method, :method_called, method_called_mock_method)
+
+      acceptor.start
+
+      instance = Bunny.instance
+      queue = instance.queues[:some_queue]
+      queue.should_not be_nil
+
+      block = queue.block
+      block.call({})
+
+      acceptor.method_called.should == 1
+    end
+  end
+end