batsir 0.3.7.1 → 0.4.0

data/spec/batsir/dsl/chain_mapping_spec.rb

@@ -1,116 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "..", "spec_helper")
-
-describe Batsir::DSL::ChainMapping do
-  it "creates a chain" do
-    block = ::Proc.new do
-      aggregator_chain do
-      end
-    end
-
-    chain = ::Blockenspiel.invoke(block, Batsir::DSL::ChainMapping.new)
-    chain.should_not be_nil
-  end
-
-  it "can add a stage" do
-    block = ::Proc.new do
-      aggregator_chain do
-        stage "simple_stage" do
-
-        end
-      end
-    end
-
-    chain = ::Blockenspiel.invoke(block, Batsir::DSL::ChainMapping.new)
-    chain.stages.should_not be_empty
-    chain.stages.size.should == 1
-    chain.stages.first.name.should == "simple_stage"
-  end
-
-  it "sets the chain of the stage to the current chain" do
-    block = ::Proc.new do
-      aggregator_chain do
-        stage "simple_stage" do
-
-        end
-      end
-    end
-
-    chain = ::Blockenspiel.invoke(block, Batsir::DSL::ChainMapping.new)
-    chain.stages.size.should == 1
-    chain.stages.first.chain.should == chain
-  end
-
-  it "can add multiple stages" do
-    block = ::Proc.new do
-      aggregator_chain do
-        stage "first_stage" do
-
-        end
-        stage "second_stage" do
-
-        end
-      end
-    end
-
-    chain = ::Blockenspiel.invoke(block, Batsir::DSL::ChainMapping.new)
-    chain.stages.should_not be_empty
-    chain.stages.size.should == 2
-    chain.stages.first.name.should == "first_stage"
-    chain.stages.last.name.should == "second_stage"
-  end
-
-  it "can create a complete aggregator chain" do
-    stage_name            = "Complete Stage"
-    operation1            = "Some Operation"
-    operation2            = "Another Operation"
-    notification_class1   = :notification_class1
-    options               = {:queue => :somequeue}
-    notification_class2   = :notification_class2
-
-    block = ::Proc.new do
-      aggregator_chain do
-        stage stage_name do
-          filter operation1
-          filter operation2
-          outbound do
-            notifier notification_class1, options
-            notifier notification_class2
-          end
-        end
-
-        stage "#{stage_name}2" do
-          filter operation1
-          filter operation2
-          outbound do
-            notifier notification_class1, options
-            notifier notification_class2
-          end
-        end
-      end
-    end
-
-    chain = ::Blockenspiel.invoke(block, Batsir::DSL::ChainMapping.new)
-    chain.should_not be_nil
-    chain.stages.size.should == 2
-    stage1 = chain.stages.first
-    stage1.should_not be_nil
-    stage1.name.should == stage_name
-
-    stage2 = chain.stages.last
-    stage2.should_not be_nil
-    stage2.name.should == "#{stage_name}2"
-
-    chain.stages.each do |stage|
-      stage.filters.should_not be_nil
-      stage.filters.should_not be_empty
-      stage.filters.should include operation1
-      stage.filters.should include operation2
-      stage.notifiers.should_not be_nil
-      stage.notifiers.should_not be_empty
-      stage.notifiers.should have_key notification_class1
-      stage.notifiers[notification_class1].first.should == options
-      stage.notifiers.should have_key notification_class2
-      stage.notifiers[notification_class2].first.should == {}
-    end
-  end
-end

data/spec/batsir/dsl/conditional_notifier_mapping_spec.rb

@@ -1,80 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "..", "spec_helper")
-
-describe Batsir::DSL::ConditionalNotifierMapping do
-  it "creates conditional notifier declarations" do
-    block = lambda do
-      conditional do
-        notify_if "message == 'sometext'", Batsir::Notifiers::Notifier
-      end
-    end
-
-    conditional = ::Blockenspiel.invoke(block, Batsir::DSL::ConditionalNotifierMapping.new)
-    conditional.notifier_declarations.should_not be_empty
-    conditional_notifier = conditional.notifier_declarations.first
-    conditional_notifier.notifier.should == Batsir::Notifiers::Notifier
-  end
-
-  it "passes options to notifiers" do
-    block = lambda do
-      conditional do
-        notify_if "true", Batsir::Notifiers::Notifier, :some => :options
-      end
-    end
-
-    conditional = ::Blockenspiel.invoke(block, Batsir::DSL::ConditionalNotifierMapping.new)
-    conditional.notifier_declarations.should_not be_empty
-    conditional_notifier = conditional.notifier_declarations.first
-    conditional_notifier.options.should have_key :some
-  end
-
-  it "can be used inside a stage" do
-    block = lambda do
-      stage "stage name" do
-        outbound do
-          conditional do
-            notify_if "true", Batsir::Notifiers::Notifier, :some => :options
-          end
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    notifier = stage.conditional_notifiers.should_not be_empty
-  end
-
-  context "compiling" do
-    before :all do
-      Celluloid.boot
-
-      block = lambda do
-        stage "stage name" do
-          outbound do
-            conditional do
-              notify_if "true", Batsir::Notifiers::Notifier
-              notify_if "false", Batsir::Notifiers::Notifier
-            end
-          end
-        end
-      end
-
-      stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-      created_class = eval( stage.compile )
-      @instance = created_class.new
-    end
-
-    it "stores the conditional notifier" do
-      @instance.filter_queue.notifiers.size == 1
-      conditional = @instance.filter_queue.notifiers.first
-      conditional.should be_kind_of Batsir::Notifiers::ConditionalNotifier
-      conditional.notifiers.size.should == 2
-      conditional.notifiers.first.condition.should be_a Proc
-    end
-
-    it "adds the default transformer" do
-      notifier = @instance.filter_queue.notifiers.first
-      notifier.transformer_queue.size.should == 1
-      notifier.transformer_queue.first.should be_kind_of Batsir::Transformers::Transformer
-    end
-  end
-end
-

data/spec/batsir/dsl/stage_mapping_spec.rb

@@ -1,453 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "..", "spec_helper")
-
-describe Batsir::DSL::StageMapping do
-  it "creates a simple stage with a name" do
-    block = ::Proc.new do
-      stage "simple_stage" do
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.name.should == "simple_stage"
-  end
-
-  it "can add a filter to the stage" do
-    filter = "Operation"
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        filter filter
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.filters.should_not be_nil
-    stage.filters.should_not be_empty
-    stage.filters.should include filter
-  end
-
-  it "can add a filter with options to the stage" do
-    filter  = "Operation"
-    options = { :option => "options" }
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        filter filter, options
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.filters.should_not be_nil
-    stage.filters.should_not be_empty
-    declaration = stage.filter_declarations.find{|decl| decl.filter == filter }
-    declaration.options.should == options
-  end
-
-  it "can add multiple filters to the stage" do
-    filter1 = "Operation 1"
-    filter2 = "Operation 2"
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        filter filter1
-        filter filter2
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.filters.should_not be_nil
-    stage.filters.should_not be_empty
-    stage.filters.should include filter1
-    stage.filters.should include filter2
-  end
-
-  it "can add an inbound section to a stage" do
-    block = ::Proc.new do
-      stage "simple_stage" do
-        inbound do
-
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.acceptors.should_not be_nil
-    stage.acceptors.should be_empty
-  end
-
-  it "can add a transformers section to the inbound section of a stage" do
-    block = ::Proc.new do
-      stage "simple_stage" do
-        inbound do
-          transformers do
-
-          end
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.acceptors.should_not be_nil
-    stage.acceptors.should be_empty
-    stage.acceptor_transformers.should be_empty
-  end
-
-  it "can add a transformer to the transformers section of the inbound section of a stage" do
-    transformer = :transformer
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        inbound do
-          transformers do
-            transformer transformer
-          end
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.acceptors.should_not be_nil
-    stage.acceptors.should be_empty
-    stage.acceptor_transformers.should_not be_empty
-    stage.acceptor_transformers.size.should == 1
-    stage.acceptor_transformers.first.transformer.should == transformer
-  end
-
-  it "can add a transformer with options to the transformers section of the inbound section of a stage" do
-    transformer = :transformer
-    options     = {:foo => :bar}
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        inbound do
-          transformers do
-            transformer transformer, options
-          end
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.acceptors.should_not be_nil
-    stage.acceptors.should be_empty
-    stage.acceptor_transformers.should_not be_empty
-    stage.acceptor_transformers.size.should == 1
-    stage.acceptor_transformers.first.transformer.should == transformer
-    stage.acceptor_transformers.first.options.should == options
-  end
-
-  it "can add multiple transformers to the transformers section of the inbound section of a stage" do
-    transformer1 = :transformer1
-    options     = {:foo => :bar}
-    transformer2 = :transformer2
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        inbound do
-          transformers do
-            transformer transformer1, options
-            transformer transformer2
-          end
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.acceptors.should_not be_nil
-    stage.acceptors.should be_empty
-    stage.acceptor_transformers.should_not be_empty
-    stage.acceptor_transformers.size.should == 2
-    stage.acceptor_transformers.first.transformer.should == transformer1
-    stage.acceptor_transformers.first.options.should == options
-    stage.acceptor_transformers.last.transformer.should == transformer2
-    stage.acceptor_transformers.last.options.should == {}
-  end
-
-  it "can add an acceptor to a stage" do
-    acceptor_class = :acceptor_class
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        inbound do
-          acceptor acceptor_class
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.acceptors.should_not be_nil
-    stage.acceptors.should_not be_empty
-    stage.acceptors.keys.should include acceptor_class
-    stage.acceptors[acceptor_class].first.should == {}
-  end
-
-  it "can add an inbound section with an acceptor with options to the stage" do
-    acceptor_class = :acceptor_class
-    options = {:foo => :bar}
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        inbound do
-          acceptor acceptor_class, options
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.acceptors.should_not be_nil
-    stage.acceptors.should_not be_empty
-    stage.acceptors.keys.should include acceptor_class
-    stage.acceptors[acceptor_class].first.should == options
-  end
-
-  it "can add multiple acceptors to a stage" do
-    acceptor_class1 = :acceptor_class1
-    options = {:foo => :bar}
-    acceptor_class2 = :acceptor_class2
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        inbound do
-          acceptor acceptor_class1, options
-          acceptor acceptor_class2
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.acceptors.should_not be_nil
-    stage.acceptors.should_not be_empty
-    stage.acceptors.keys.should include acceptor_class1
-    stage.acceptors[acceptor_class1].first.should == options
-    stage.acceptors.keys.should include acceptor_class2
-    stage.acceptors[acceptor_class2].first.should == {}
-  end
-
-  it "can add an outbound section without any notifiers" do
-    block = ::Proc.new do
-      stage "simple_stage" do
-        outbound do
-
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.notifiers.should_not be_nil
-    stage.notifiers.should be_empty
-  end
-
-  it "can add a transformers section to the outbound section of a stage" do
-    block = ::Proc.new do
-      stage "simple_stage" do
-        outbound do
-          transformers do
-
-          end
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.notifiers.should_not be_nil
-    stage.notifiers.should be_empty
-    stage.notifier_transformers.should be_empty
-  end
-
-  it "can add a transformer to the transformers section of the outbound section of a stage" do
-    transformer = :transformer
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        outbound do
-          transformers do
-            transformer transformer
-          end
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.notifiers.should_not be_nil
-    stage.notifiers.should be_empty
-    stage.notifier_transformers.should_not be_empty
-    stage.notifier_transformers.size.should == 1
-    stage.notifier_transformers.first.transformer.should == transformer
-  end
-
-  it "can add a transformer with options to the transformers section of the outbound section of a stage" do
-    transformer = :transformer
-    options     = {:foo => :bar}
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        outbound do
-          transformers do
-            transformer transformer, options
-          end
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.notifiers.should_not be_nil
-    stage.notifiers.should be_empty
-    stage.notifier_transformers.should_not be_empty
-    stage.notifier_transformers.size.should == 1
-    stage.notifier_transformers.first.transformer.should == transformer
-    stage.notifier_transformers.first.options.should == options
-  end
-
-  it "can add multiple transformers to the transformers section of the outbound section of a stage" do
-    transformer1 = :transformer1
-    options     = {:foo => :bar}
-    transformer2 = :transformer2
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        outbound do
-          transformers do
-            transformer transformer1, options
-            transformer transformer2
-          end
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.notifiers.should_not be_nil
-    stage.notifiers.should be_empty
-    stage.notifier_transformers.should_not be_empty
-    stage.notifier_transformers.size.should == 2
-    stage.notifier_transformers.first.transformer.should == transformer1
-    stage.notifier_transformers.first.options.should == options
-    stage.notifier_transformers.last.transformer.should == transformer2
-    stage.notifier_transformers.last.options.should == {}
-  end
-
-  it "can add an outbound section to the stage" do
-    notification_class = :notification_class
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        outbound do
-          notifier notification_class
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.notifiers.should_not be_empty
-    stage.notifiers.should have_key notification_class
-    stage.notifiers[notification_class].first.should == {}
-  end
-
-  it "can add an outbound section with a notifier with options to the stage" do
-    notification_class = :notification_class
-    options = {:queue => :somequeue}
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        outbound do
-          notifier notification_class, options
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.notifiers.should_not be_empty
-    stage.notifiers.should have_key notification_class
-    stage.notifiers[notification_class].first.should == options
-  end
-
-  it "can add multiple notifiers to the stage" do
-    notification_class1 = :notification_class1
-    options             = {:queue => :somequeue}
-    notification_class2 = :notification_class2
-
-    block = ::Proc.new do
-      stage "simple_stage" do
-        outbound do
-          notifier notification_class1, options
-          notifier notification_class2
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.notifiers.should_not be_empty
-    stage.notifiers.should have_key notification_class1
-    stage.notifiers[notification_class1].first.should == options
-
-    stage.notifiers.should have_key notification_class2
-    stage.notifiers[notification_class2].first.should == {}
-  end
-
-  it "can create a complete stage" do
-    acceptor_class1     = :acceptor_class1
-    options             = {:foo => :bar}
-    acceptor_class2     = :acceptor_class2
-    stage_name          = "Complete Stage"
-    filter1             = "Some Filter"
-    filter2             = "Another Filter"
-    notification_class1 = :notification_class1
-    options             = {:queue => :somequeue}
-    notification_class2 = :notification_class2
-
-    block = ::Proc.new do
-      stage stage_name do
-        inbound do
-          acceptor acceptor_class1, options
-          acceptor acceptor_class2
-        end
-        filter filter1
-        filter filter2
-        outbound do
-          notifier notification_class1, options
-          notifier notification_class2
-        end
-      end
-    end
-
-    stage = ::Blockenspiel.invoke(block, Batsir::DSL::StageMapping.new)
-    stage.should_not be_nil
-    stage.name.should == stage_name
-    stage.acceptors.should_not be_nil
-    stage.acceptors.should_not be_empty
-    stage.acceptors.keys.should include acceptor_class1
-    stage.acceptors[acceptor_class1].first.should == options
-    stage.acceptors.keys.should include acceptor_class2
-    stage.acceptors[acceptor_class2].first.should == {}
-    stage.filters.should_not be_nil
-    stage.filters.should_not be_empty
-    stage.filters.should include filter1
-    stage.filters.should include filter2
-    stage.notifiers.should_not be_nil
-    stage.notifiers.should_not be_empty
-    stage.notifiers.should have_key notification_class1
-    stage.notifiers[notification_class1].first.should == options
-
-    stage.notifiers.should have_key notification_class2
-    stage.notifiers[notification_class2].first.should == {}
-  end
-end

data/spec/batsir/filter_queue_spec.rb

@@ -1,68 +0,0 @@
-require File.join( File.dirname(__FILE__), "..", "spec_helper" )
-
-describe Batsir::FilterQueue do
-  it "can add a filter to a queue" do
-    queue = Batsir::FilterQueue.new
-    queue.add("Filter")
-    queue.should include "Filter"
-  end
-
-  it "does 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 "can add a notifier" do
-    queue = Batsir::FilterQueue.new
-    notifier = "Notifier"
-    queue.add_notifier(notifier)
-    queue.should include notifier
-  end
-
-  it "can 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 "returns notifiers as the last operations" do
-    notifier = "Notifier"
-    queue = Batsir::FilterQueue.new
-    queue.add("SomeFilter")
-    queue.add_notifier(notifier)
-    queue.add("AnotherFilter")
-
-    ops = []
-    queue.each do |op|
-      ops << op
-    end
-    ops.last.should == notifier
-  end
-
-  it "responds true to #empty? when no operations are added" do
-    queue = Batsir::FilterQueue.new
-    queue.should be_empty
-  end
-
-  it "is not 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 "is not empty when a regular operation is added" do
-    queue = Batsir::FilterQueue.new
-    queue.add("SomeFilter")
-    queue.should_not be_empty
-  end
-end