batsir 0.1.0

data/spec/batsir/filter_queue_spec.rb

@@ -0,0 +1,74 @@
+require File.join( File.dirname(__FILE__), "..", "spec_helper" )
+
+describe Batsir::FilterQueue do
+  it "should be possible to add a filter to a queue" do
+    queue = Batsir::FilterQueue.new
+    queue.add("Filter")
+    queue.should include "Filter"
+  end
+
+  it "should not return nil as last operation when no acceptors or notifiers are added" do
+    queue = Batsir::FilterQueue.new
+
+    queue.add("AnotherFilter")
+    ops = []
+    queue.each do |op|
+      ops << op
+    end
+    ops.last.should_not be_nil
+  end
+
+  it "should be possible to add a notifier" do
+    queue = Batsir::FilterQueue.new
+    notifier = "Notifier"
+    queue.add_notifier(notifier)
+    queue.should include notifier
+  end
+
+  it "should be possible to add multiple notifiers" do
+    queue = Batsir::FilterQueue.new
+    ops = []
+    3.times do |index|
+      ops << "Notifier #{index}"
+      queue.add_notifier("Notifier #{index}")
+    end
+
+    ops.each {|op| queue.should include op}
+  end
+
+  it "should return notifiers as the last operations" do
+    queue = Batsir::FilterQueue.new
+    notifier = "Notifier"
+
+    queue.add("SomeFilter")
+    queue.add_notifier(notifier)
+    queue.add("AnotherFilter")
+
+    ops = []
+    queue.each do |op|
+      ops << op
+    end
+    ops.last.should == notifier
+  end
+
+  it "should respond true to #empty? when no operations are added" do
+    queue = Batsir::FilterQueue.new
+    queue.should be_empty
+  end
+
+  it "should not be empty when a notification operation is added" do
+    queue = Batsir::FilterQueue.new
+    operation = "Notifier"
+
+    queue.add_notifier(operation)
+
+    queue.should_not be_empty
+  end
+
+  it "should not be empty when a regular operation is added" do
+    queue = Batsir::FilterQueue.new
+
+    queue.add("SomeFilter")
+    queue.should_not be_empty
+  end
+end

data/spec/batsir/filter_spec.rb

@@ -0,0 +1,12 @@
+require File.join( File.dirname(__FILE__), "..", "spec_helper" )
+
+describe Batsir::Filter do
+  it "should be possible to create an filter" do
+    filter = Batsir::Filter.new
+    filter.should_not be_nil
+  end
+
+  it "should have an #execute method" do
+    Batsir::Filter.instance_methods.map{|im| im.to_s}.should include "execute"
+  end
+end

data/spec/batsir/notifiers/amqp_notifier_spec.rb

@@ -0,0 +1,117 @@
+require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+
+describe Batsir::Notifiers::AMQPNotifier do
+  let(:notifier_class){
+    Batsir::Notifiers::AMQPNotifier
+  } 
+
+  context "With respect to setting options" do
+    it "should be a Batsir::Notifiers::Notifier" do
+      notifier_class.ancestors.should include Batsir::Notifiers::Notifier
+    end
+
+    it "should be possible to set the queue on which to listen" do
+      notifier = notifier_class.new(:queue => :queue)
+      notifier.queue.should == :queue
+    end
+
+    it "should be possible to set the host of the amqp broker" do
+      notifier = notifier_class.new(:host => 'localhost')
+      notifier.host.should == 'localhost'
+    end
+
+    it "should be possible to set the port of the amqp broker" do
+      notifier = notifier_class.new(:port => 1234)
+      notifier.port.should == 1234
+    end
+
+    it "should be possible to set the username with which to connect to the broker" do
+      notifier = notifier_class.new(:username => 'some_user')
+      notifier.username.should == 'some_user'
+    end
+
+    it "should be possible to set the password with which to connect to the broker" do
+      notifier = notifier_class.new(:password => 'password')
+      notifier.password.should == 'password'
+    end
+
+    it "should be possible to set the vhost to use on the broker" do
+      notifier = notifier_class.new(:vhost => '/blah')
+      notifier.vhost.should == '/blah'
+    end
+
+    it "should be possible to set the exchange to use on the broker" do
+      notifier = notifier_class.new(:exchange => 'amq.direct')
+      notifier.exchange.should == 'amq.direct'
+    end
+
+    it "should default to amqp://guest:guest@localhost:5672/ with direct exchange on vhost ''" do
+      notifier = notifier_class.new(:queue => :somequeue)
+      notifier.queue.should    == :somequeue
+      notifier.host.should     == 'localhost'
+      notifier.port.should     == 5672
+      notifier.username.should == 'guest'
+      notifier.password.should == 'guest'
+      notifier.vhost.should    == '/'
+      notifier.exchange.should == 'amq.direct'
+    end
+  end
+
+  context "With respect to notifying" do
+    def new_notifier(options = {})
+      notifier_class.new(options)
+    end
+
+    it "should connect to the configured host" do
+      notifier = new_notifier(:host => 'somehost')
+      notifier.execute({})
+      instance = Bunny.instance
+      instance.options[:host].should == 'somehost'
+    end
+
+    it "should connect to the configured port" do
+      notifier = new_notifier(:port => 1234)
+      notifier.execute({})
+      instance = Bunny.instance
+      instance.options[:port].should == 1234
+    end
+
+    it "should connect with the configured username" do
+      notifier = new_notifier(:username => 'user')
+      notifier.execute({})
+      instance = Bunny.instance
+      instance.options[:user].should == 'user'
+    end
+
+    it "should connect with the configured password" do
+      notifier = new_notifier(:password => 'pass')
+      notifier.execute({})
+      instance = Bunny.instance
+      instance.options[:pass].should == 'pass'
+    end
+
+    it "should connect to the configured vhost" do
+      notifier = new_notifier(:vhost => '/vhost')
+      notifier.execute({})
+      instance = Bunny.instance
+      instance.options[:vhost].should == '/vhost'
+    end
+
+    it "should declare the configured exchange" do
+      notifier = new_notifier(:exchange => 'some_exchange')
+      notifier.execute({})
+      instance = Bunny.instance
+      instance.exchange.name.should == 'some_exchange'
+    end
+
+    it "should bind the configured exchange to the queue and publish the message with the queue set as routing key" do
+      notifier = new_notifier(:exchange => 'some_exchange', :queue => :queue)
+      notifier.execute({})
+      instance = Bunny.instance
+      instance.exchange.name.should == 'some_exchange'
+      instance.exchange.message.should == {}
+      instance.exchange.key.should == :queue
+    end
+
+  end
+end

data/spec/batsir/notifiers/notifier_spec.rb

@@ -0,0 +1,73 @@
+require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+
+describe Batsir::Notifiers::Notifier do
+  let( :notifier_class ) do
+    Batsir::Notifiers::Notifier
+  end
+
+  it "should have a transformer_queue" do
+    notifier = notifier_class.new
+    notifier.transformer_queue.should_not be_nil
+  end
+
+  it "should initially have an empty transformer_queue" do
+    notifier = notifier_class.new
+    notifier.transformer_queue.should_not be_nil
+    notifier.transformer_queue.should be_empty
+  end
+
+  it "should be possible to add a transformer to the transformer_queue" do
+    transformer = :transformer
+
+    notifier = notifier_class.new
+    notifier.add_transformer transformer
+
+    notifier.transformer_queue.should_not be_empty
+    notifier.transformer_queue.size.should == 1
+    notifier.transformer_queue.first.should == :transformer
+  end
+
+  it "should be possible to add a transformer multiple times" do
+    transformer = :transformer
+
+    notifier = notifier_class.new
+    notifier.add_transformer transformer
+    notifier.add_transformer transformer
+
+    notifier.transformer_queue.should_not be_empty
+    notifier.transformer_queue.size.should == 2
+  end
+
+  it "should create a FieldTransformer when the 'fields' option is given during initialization" do
+    fields = {:foo => :bar}
+    notifier = notifier_class.new(:fields => fields)
+    notifier.transformer_queue.should_not be_empty
+    notifier.transformer_queue.first.class.should == Batsir::Transformers::FieldTransformer
+    notifier.transformer_queue.first.fields.should == fields
+  end
+
+  it "should call #transform when #notify is called" do
+    notifier = notifier_class.new
+    notifier.should_receive(:transform).with({})
+    notifier.notify({})
+  end
+
+  it "should call #transform on all transformers when #transform is called" do
+    class MockTransformer < Batsir::Transformers::Transformer
+    end
+
+    notifier = notifier_class.new
+    transformer = MockTransformer.new
+    notifier.add_transformer transformer
+    notifier.transformer_queue.size.should == 1
+
+    transformer.should_receive(:transform).with({})
+    notifier.notify({})
+  end
+
+  it "should call #execute when #notify is called" do
+    notifier = notifier_class.new
+    notifier.should_receive(:execute)
+    notifier.notify({})
+  end
+end

data/spec/batsir/stage_spec.rb

@@ -0,0 +1,678 @@
+require File.join( File.dirname(__FILE__), "..", "spec_helper" )
+
+describe Batsir::Stage do
+  def create_stage(options = {})
+    defaults = {
+      :name   => "Test Stage",
+      :chain  => Batsir::Chain.new
+    }
+    Batsir::Stage.new(defaults.merge(options))
+  end
+
+  before :all do
+    class StubFilter < Batsir::Filter
+    end
+
+    class AnotherFilter < Batsir::Filter
+    end
+
+    @object_type = "SomeResource"
+  end
+
+  it "should be a Celluloid Actor" do
+    Batsir::Stage.ancestors.should include Celluloid
+  end
+
+  it "should be possible to name the stage" do
+    stage = Batsir::Stage.new
+    name = "StageName"
+    stage.name = name
+    stage.name.should == name
+  end
+
+  it "should be possible to set the name in the constructor" do
+    name = "StageName"
+    stage = Batsir::Stage.new(:name => name)
+    stage.name.should == name
+  end
+
+  it "should be possible to set the aggregator chain to which the stage belongs" do
+    chain = "Chain"
+    stage = Batsir::Stage.new(:chain => chain)
+    stage.chain.should == chain
+  end
+
+  context "With respect to filters" do
+    it "should not be possible to set the filters" do
+      stage = Batsir::Stage.new
+      lambda { stage.filters = {} }.should raise_error(NoMethodError)
+    end
+
+    it "should store filters using filter declarations" do
+      filter = "Filter"
+      stage = Batsir::Stage.new
+      stage.add_filter(filter)
+      stage.filter_declarations.should_not be_nil
+      stage.filter_declarations.size.should == 1
+      declaration = stage.filter_declarations.first
+      declaration.filter.should == filter
+      declaration.options.should == {}
+    end
+
+    it "should return an empty array when the #filters method is called without any declared filters" do
+      stage = Batsir::Stage.new
+      stage.filters.should_not be_nil
+      stage.filters.should == []
+    end
+
+    it "should return all filters when the #filters method is called" do
+      filter1 = "Filter"
+      filter2 = "Filter2"
+      filter3 = "Filter"
+      stage = Batsir::Stage.new
+      stage.add_filter(filter1)
+      stage.add_filter(filter2)
+      stage.add_filter(filter3)
+
+      stage.filters.should_not be_nil
+      stage.filters.size.should == 3
+      stage.filters[0].should == filter1
+      stage.filters[1].should == filter2
+      stage.filters[2].should == filter3
+    end
+
+    it "should add a filter to its filters" do
+      filter = "Filter"
+      stage = Batsir::Stage.new
+      stage.add_filter(filter)
+      stage.filters.should_not be_nil
+      stage.filters.should include filter
+    end
+
+    it "should be possible to have multiple filters of the same class but with different options" do
+      stage = Batsir::Stage.new
+      stage.add_filter(:filter)
+      stage.add_filter(:filter, :foo => :bar)
+
+      stage.filters.should include :filter
+      stage.filters.size.should == 2
+    end
+
+    it "should be possible to add filters with on options hash" do
+      filter = :filter
+      options = {:foo => :bar}
+
+      stage = Batsir::Stage.new
+      stage.add_filter(filter, options)
+
+      stage.filters.should_not be_nil
+      stage.filters.should_not be_empty
+      stage.filters.should include filter
+      stage.filter_declarations.first.options.should == options
+    end
+
+    it "should be possible to add multiple filters with option hashes" do
+      filter1 = :filter1
+      filter2 = :filter2
+      options1 = {:foo1 => :bar1}
+      options2 = {:foo2 => :bar2}
+
+      stage = Batsir::Stage.new
+      stage.add_filter(filter1, options1)
+      stage.add_filter(filter2, options2)
+
+      stage.filters.should include filter1
+      stage.filters.should include filter2
+      stage.filter_declarations[0].options.should == options1
+      stage.filter_declarations[1].options.should == options2
+    end
+
+    it "should add empty options hashes to filters when no option hash is given" do
+      filter = :filter
+
+      stage = Batsir::Stage.new
+      stage.add_filter(filter)
+
+      stage.filters.should_not be_nil
+      stage.filters.should_not be_empty
+      stage.filters.should include filter
+      stage.filter_declarations.first.options.should == {}
+    end
+
+    it "should be possible to add a filter more than once" do
+      filter = :filter
+      stage = Batsir::Stage.new
+      stage.add_filter(filter)
+      stage.add_filter(filter)
+      stage.filters.should_not be_nil
+      stage.filters.should_not be_empty
+      stage.filters.size.should == 2
+    end
+
+    it "should be possible to add filter with different options and respect the order" do
+      filter = :filter
+      other_filter = :other_filter
+
+      stage = Batsir::Stage.new
+      stage.add_filter(filter)
+      stage.add_filter(other_filter)
+      stage.add_filter(filter, :foo => :bar)
+      stage.filters.size.should == 3
+    end
+  end
+
+  context "With respect to acceptors" do
+    it "should initially have an empty list of acceptors" do
+      stage = Batsir::Stage.new
+      stage.acceptors.should_not be_nil
+      stage.acceptors.should be_empty
+    end
+
+    it "should not be possible to set the acceptors" do
+      stage = Batsir::Stage.new
+      lambda { stage.acceptors = {} }.should raise_error(NoMethodError)
+    end
+
+    it "should be possible to add new acceptors" do
+      stage = Batsir::Stage.new
+      stage.add_acceptor(:acceptor)
+      stage.acceptors.should_not be_nil
+      stage.acceptors.should_not be_empty
+      stage.acceptors.keys.should include :acceptor
+    end
+
+    it "should store a set of different options for each acceptor" do
+      stage = Batsir::Stage.new
+      stage.add_acceptor(:acceptor)
+      stage.acceptors[:acceptor].should be_a Set
+    end
+
+    it "should be possible to have multiple acceptors of the same class but with different options" do
+      stage = Batsir::Stage.new
+      stage.add_acceptor(:acceptor_class)
+      stage.add_acceptor(:acceptor_class, :foo => :bar)
+
+      stage.acceptors.should_not be_nil
+      stage.acceptors.should_not be_empty
+      stage.acceptors.keys.should include :acceptor_class
+      stage.acceptors[:acceptor_class].size.should == 2
+    end
+
+    it "should be possible to add an acceptor with an options hash" do
+      stage = Batsir::Stage.new
+      options = {:foo => :bar}
+      stage.add_acceptor(:acceptor, options)
+
+      stage.acceptors.should_not be_nil
+      stage.acceptors.should_not be_empty
+      stage.acceptors.keys.should include :acceptor
+      stage.acceptors[:acceptor].first.should == options
+    end
+
+    it "should add an empty options hash for added acceptors without options" do
+      stage = Batsir::Stage.new
+      stage.add_acceptor(:acceptor)
+
+      stage.acceptors.should_not be_nil
+      stage.acceptors.should_not be_empty
+      stage.acceptors.keys.should include :acceptor
+      stage.acceptors[:acceptor].first.should == {}
+    end
+
+    it "should initially have an empty list of cancellators" do
+      stage = Batsir::Stage.new
+      stage.cancellators.should_not be_nil
+      stage.cancellators.should be_empty
+    end
+
+    context "with respect to acceptor transformers" do
+      it "should have an empty acceptor transformers queue by default" do
+        stage = Batsir::Stage.new
+
+        stage.acceptor_transformers.should_not be_nil
+        stage.acceptor_transformers.should be_empty
+      end
+
+      it "should be possible to add a transformer to the acceptors" do
+        stage = Batsir::Stage.new
+
+        transformer = :transformer
+
+        stage.add_acceptor_transformer(transformer)
+        stage.acceptor_transformers.should_not be_empty
+
+        stage.acceptor_transformers.first.transformer.should == transformer
+      end
+
+      it "should add an empty options hash by default" do
+        stage = Batsir::Stage.new
+
+        transformer = :transformer
+        stage.add_acceptor_transformer(transformer)
+        stage.acceptor_transformers.should_not be_empty
+
+        stage.acceptor_transformers.first.options.should == {}
+      end
+
+      it "should be possible to add options to a transformer" do
+        stage = Batsir::Stage.new
+
+        transformer = :transformer
+        options = {:foo => :bar}
+
+        stage.add_acceptor_transformer(transformer, options)
+        stage.acceptor_transformers.should_not be_empty
+
+        stage.acceptor_transformers.first.transformer.should == transformer
+        stage.acceptor_transformers.first.options.should == options
+      end
+
+      it "should be possible to add multiple transformers" do
+        stage = Batsir::Stage.new
+
+        transformer1 = :transformer1
+        transformer2 = :transformer2
+
+        stage.add_acceptor_transformer(transformer1)
+        stage.add_acceptor_transformer(transformer2)
+        stage.acceptor_transformers.should_not be_empty
+        stage.acceptor_transformers.size.should == 2
+
+        transformers = stage.acceptor_transformers.map{|td| td.transformer}
+        transformers.should include transformer1
+        transformers.should include transformer2
+      end
+
+      it "should keep the transformers in the order of declaration" do
+        stage = Batsir::Stage.new
+
+        transformer1 = :transformer1
+        transformer2 = :transformer2
+
+        stage.add_acceptor_transformer(transformer1)
+        stage.add_acceptor_transformer(transformer2)
+        stage.acceptor_transformers.should_not be_empty
+        stage.acceptor_transformers.size.should == 2
+
+        stage.acceptor_transformers.first.transformer.should == transformer1
+        stage.acceptor_transformers.last.transformer.should == transformer2
+      end
+
+      it "should be possible to add a transformer more than once" do
+        stage = Batsir::Stage.new
+
+        transformer = :transformer
+
+        stage.add_acceptor_transformer(transformer)
+        stage.add_acceptor_transformer(transformer)
+        stage.acceptor_transformers.should_not be_empty
+        stage.acceptor_transformers.size.should == 2
+
+        stage.acceptor_transformers.first.transformer.should == transformer
+        stage.acceptor_transformers.last.transformer.should == transformer
+      end
+    end
+
+  end
+
+  context "With respect to notifiers" do
+    it "should initially have an empty notifiers queue" do
+      stage = Batsir::Stage.new
+      stage.notifiers.should_not be_nil
+      stage.notifiers.should be_empty
+    end
+
+    it "should not be possible to set the notifiers" do
+      stage = Batsir::Stage.new
+      lambda { stage.notifiers = {} }.should raise_error(NoMethodError)
+    end
+
+    it "should be possible to add new notifiers" do
+      stage = Batsir::Stage.new
+
+      stage.add_notifier(:notifier)
+      stage.notifiers.should_not be_nil
+      stage.notifiers.should_not be_empty
+      stage.notifiers.keys.should include :notifier
+    end
+
+    it "should store a set of different options for each notifier" do
+      stage = Batsir::Stage.new
+      stage.add_notifier(:notifier)
+      stage.notifiers[:notifier].should be_a Set
+    end
+
+    it "should be possible to have multiple notifiers of the same class but with different options" do
+      stage = Batsir::Stage.new
+      stage.add_notifier(:notifier_class)
+      stage.add_notifier(:notifier_class, :foo => :bar)
+
+      stage.notifiers.should_not be_nil
+      stage.notifiers.keys.should include :notifier_class
+      stage.notifiers[:notifier_class].size.should == 2
+    end
+
+    it "should be possible to set a notifier with an options hash" do
+      stage = Batsir::Stage.new
+
+      options = {:foo => :bar}
+
+      stage.add_notifier(:notifier, options)
+      stage.notifiers.should_not be_nil
+      stage.notifiers.should_not be_empty
+      stage.notifiers.keys.should include :notifier
+      stage.notifiers[:notifier].first.should == options
+    end
+
+    it "should add an empty options hash for added notifiers without options" do
+      stage = Batsir::Stage.new
+
+      stage.add_notifier(:notifier)
+      stage.notifiers.should_not be_nil
+      stage.notifiers.should_not be_empty
+      stage.notifiers.keys.should include :notifier
+      stage.notifiers[:notifier].first.should == {}
+    end
+
+    context "with respect to notifier transformers" do
+      it "should have an empty notifier transformers queue by default" do
+        stage = Batsir::Stage.new
+
+        stage.notifier_transformers.should_not be_nil
+        stage.notifier_transformers.should be_empty
+      end
+
+      it "should be possible to add a transformer to the notifiers" do
+        stage = Batsir::Stage.new
+
+        transformer = :transformer
+
+        stage.add_notifier_transformer(transformer)
+        stage.notifier_transformers.should_not be_empty
+
+        stage.notifier_transformers.first.transformer.should == transformer
+      end
+
+      it "should add an empty options hash by default" do
+        stage = Batsir::Stage.new
+
+        transformer = :transformer
+        stage.add_notifier_transformer(transformer)
+        stage.notifier_transformers.should_not be_empty
+
+        stage.notifier_transformers.first.options.should == {}
+      end
+
+      it "should be possible to add options to a transformer" do
+        stage = Batsir::Stage.new
+
+        transformer = :transformer
+        options = {:foo => :bar}
+
+        stage.add_notifier_transformer(transformer, options)
+        stage.notifier_transformers.should_not be_empty
+
+        stage.notifier_transformers.first.transformer.should == transformer
+        stage.notifier_transformers.first.options.should == options
+      end
+
+      it "should be possible to add multiple transformers" do
+        stage = Batsir::Stage.new
+
+        transformer1 = :transformer1
+        transformer2 = :transformer2
+
+        stage.add_notifier_transformer(transformer1)
+        stage.add_notifier_transformer(transformer2)
+        stage.notifier_transformers.should_not be_empty
+        stage.notifier_transformers.size.should == 2
+
+        transformers = stage.notifier_transformers.map{|td| td.transformer}
+        transformers.should include transformer1
+        transformers.should include transformer2
+      end
+
+      it "should keep the transformers in the order of declaration" do
+        stage = Batsir::Stage.new
+
+        transformer1 = :transformer1
+        transformer2 = :transformer2
+
+        stage.add_notifier_transformer(transformer1)
+        stage.add_notifier_transformer(transformer2)
+        stage.notifier_transformers.should_not be_empty
+        stage.notifier_transformers.size.should == 2
+
+        stage.notifier_transformers.first.transformer.should == transformer1
+        stage.notifier_transformers.last.transformer.should == transformer2
+      end
+
+      it "should be possible to add a transformer more than once" do
+        stage = Batsir::Stage.new
+
+        transformer = :transformer
+
+        stage.add_notifier_transformer(transformer)
+        stage.add_notifier_transformer(transformer)
+        stage.notifier_transformers.should_not be_empty
+        stage.notifier_transformers.size.should == 2
+
+        stage.notifier_transformers.first.transformer.should == transformer
+        stage.notifier_transformers.last.transformer.should == transformer
+      end
+    end
+  end
+
+  context "with respect to compiling the stage" do
+    before :all do
+      @stage_name = "Stage 1"
+
+      stage = Batsir::Stage.new(:name => @stage_name)
+
+      stage.add_notifier_transformer(Batsir::Transformers::Transformer)
+      stage.add_notifier(Batsir::Notifiers::Notifier)
+      stage.add_filter(Batsir::Filter)
+      stage.add_filter(Batsir::Filter)
+
+      @created_class = eval( stage.compile )
+    end
+
+    it "should create a class named after the stage name" do
+      @created_class.to_s.should == "Stage1Worker"
+    end
+
+    it "should create a Batsir::StageWorker class" do
+      @created_class.ancestors.should include Batsir::StageWorker
+    end
+
+    it "should create a class that includes Sidekiq::Worker" do
+      @created_class.ancestors.should include Sidekiq::Worker
+    end
+
+    it "should create a worker class named after the stage name" do
+      @created_class.stage_name.should == @stage_name
+    end
+
+    it "should add the notifier during compilation" do
+      instance = @created_class.new
+      instance.filter_queue.notifiers.should_not be_nil
+      instance.filter_queue.notifiers.should_not be_empty
+      instance.filter_queue.notifiers.size.should == 1
+      instance.filter_queue.notifiers.first.should be_a Batsir::Notifiers::Notifier
+    end
+
+    it "should add a transformer to the notifier during compilation" do
+      instance = @created_class.new
+
+      instance.filter_queue.notifiers.first.transformer_queue.should_not be_empty
+      instance.filter_queue.notifiers.first.transformer_queue.first.should be_a Batsir::Transformers::Transformer
+    end
+
+    it "should add a JSONOutputTransformer by default when no transformers are defined" do
+      stage = Batsir::Stage.new(:name => "SomeName")
+
+      stage.add_notifier(Batsir::Notifiers::Notifier)
+
+      created_class = eval( stage.compile )
+      instance = created_class.new
+
+      instance.filter_queue.notifiers.should_not be_nil
+      instance.filter_queue.notifiers.should_not be_empty
+      instance.filter_queue.notifiers.first.transformer_queue.should_not be_empty
+      instance.filter_queue.notifiers.first.transformer_queue.first.should be_a Batsir::Transformers::JSONOutputTransformer
+    end
+
+    it "should initialize a class local filter queue" do
+      @created_class.filter_queue.should_not be_nil
+      @created_class.filter_queue.should_not be_empty
+    end
+
+    it "should have intitialized the filters" do
+      @created_class.filter_queue.map{|filter| filter.class.to_s}.should include "Batsir::Filter"
+    end
+    
+    it "should be possible to add a filter multiple times" do
+      @created_class.filter_queue.select{ |filter| filter.class == Batsir::Filter }.size.should == 2
+    end
+
+    it "should use the class local filter queue once an instance is initialized" do
+      instance = @created_class.new
+      instance.filter_queue.should == @created_class.filter_queue
+    end
+
+    it "should initialize all filters in the filter queue" do
+      @created_class.filter_queue.each do |filter|
+        filter.should_not be_a Class
+      end
+    end
+  end
+
+  context "with respect to starting the stage" do
+    before :all do
+      class MockAcceptor < Batsir::Acceptors::Acceptor
+
+        def foo=(bar)
+        end
+
+        def stage_name=(name)
+          @@stage_name = name
+        end
+
+        def self.stage_name
+          @@stage_name
+        end
+
+        def start
+          @@start_count ||= 0
+          @@start_count += 1
+        end
+
+        def add_transformer(transformer)
+          @@added_transformers ||= []
+          @@added_transformers << transformer
+        end
+
+        def self.added_transformers
+          @@added_transformers ||= []
+        end
+
+        def self.start_count
+          @@start_count ||= 0
+        end
+
+        def self.reset
+          @@start_count = 0
+          @@stage_name = nil
+          @@added_transformers = []
+        end
+
+      end
+
+      class Celluloid::ActorProxy
+        def start!
+          Celluloid::Actor.call @mailbox, :start
+        end
+      end
+    end
+
+    before :each do
+      MockAcceptor.reset
+    end
+
+    it "should set the stage name on acceptors when they are started" do
+      stage = create_stage
+      stage.add_acceptor MockAcceptor
+      stage.add_acceptor MockAcceptor, :foo => :bar
+
+      stage.start
+      MockAcceptor.stage_name.should == stage.name
+    end
+
+    it "should initially have an empty list of running acceptors" do
+      stage = create_stage
+      stage.add_acceptor MockAcceptor
+
+      stage.running_acceptors.should_not be_nil
+      stage.running_acceptors.should be_empty
+    end
+
+    it "should keep track of running acceptors" do
+      stage = create_stage
+      stage.add_acceptor MockAcceptor
+
+      stage.start
+      stage.running_acceptors.size.should == 1
+    end
+
+    it "should add a cancellator to each acceptor" do
+      stage = create_stage
+      stage.add_acceptor MockAcceptor
+
+      stage.start
+      stage.running_acceptors.first.cancellator.should_not be_nil
+    end
+
+    it "should add cancellators to the stage list of cancellators" do
+      stage = create_stage
+      stage.add_acceptor MockAcceptor
+      stage.add_acceptor MockAcceptor, :foo => :bar
+
+      stage.start
+      stage.cancellators.size.should == 2
+    end
+
+    it "should start all acceptors" do
+      stage = create_stage
+      stage.add_acceptor MockAcceptor
+      stage.add_acceptor MockAcceptor, :foo => :bar
+
+      MockAcceptor.start_count.should == 0
+
+      stage.start
+      sleep(0.01)
+
+      MockAcceptor.start_count.should == 2
+    end
+
+    it "should add a Batsir::Transformers::JSONInputTransformer to acceptors when no transformers are defined" do
+      stage = create_stage
+      stage.add_acceptor MockAcceptor
+
+      stage.start
+
+      MockAcceptor.added_transformers.size.should == 1
+      MockAcceptor.added_transformers.first.should be_a Batsir::Transformers::JSONInputTransformer
+    end
+
+    it "should add defined transformers to the acceptors" do
+      stage = create_stage
+      stage.add_acceptor_transformer Batsir::Transformers::Transformer
+      stage.add_acceptor MockAcceptor
+
+      stage.start
+
+      MockAcceptor.added_transformers.size.should == 1
+      MockAcceptor.added_transformers.first.should be_a Batsir::Transformers::Transformer
+    end
+  end
+end