batsir 0.1.0 → 0.3.7

data/spec/batsir/notifiers/amqp_notifier_spec.rb

@@ -1,51 +1,58 @@
 require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+require File.join( File.dirname(__FILE__), 'shared_examples')
 
 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
+  def new_notifier(options = {})
+    notifier_class.new(options)
+  end
+
+  it_should_behave_like "a notifier", Batsir::Notifiers::AMQPNotifier
+
+  context "with respect to setting options" do
+    it "is 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
+    it "can 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
+    it "can 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
+    it "can 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
+    it "can 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
+    it "can 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
+    it "can 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
+    it "can 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
+    it "defaults 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'
@@ -57,54 +64,62 @@ describe Batsir::Notifiers::AMQPNotifier do
     end
   end
 
-  context "With respect to notifying" do
-    def new_notifier(options = {})
-      notifier_class.new(options)
+  context "with respect to notifying" do
+    before :each do
+      Batsir::Registry.reset
+    end
+
+    it 'has an #execute method' do
+      notifier_class.instance_methods.map{|m| m.to_s}.should include "execute"
     end
 
-    it "should connect to the configured host" do
+    it 'has a #handle_error method' do
+      notifier_class.instance_methods.map{|m| m.to_s}.should include "handle_error"
+    end
+
+    it "connects 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
+    it "connects 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
+    it "connects with the configured username" do
       notifier = new_notifier(:username => 'user')
       notifier.execute({})
       instance = Bunny.instance
-      instance.options[:user].should == 'user'
+      instance.user.should == 'user'
     end
 
-    it "should connect with the configured password" do
+    it "connects 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
+    it "connects 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
+    it "declares 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
+    it "binds 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
@@ -112,6 +127,12 @@ describe Batsir::Notifiers::AMQPNotifier do
       instance.exchange.message.should == {}
       instance.exchange.key.should == :queue
     end
+  end
 
+  context "with respect to error handling" do
+    it 'uses a strategy object to resolve notification errors' do
+      notifier = new_notifier(:exchange => 'some_exchange', :queue => :queue)
+      notifier.error_strategy.should be_a Batsir::Strategies::RetryStrategy
+    end
   end
 end

data/spec/batsir/notifiers/conditional_notifier_spec.rb

@@ -0,0 +1,62 @@
+require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+require File.join( File.dirname(__FILE__), 'shared_examples')
+
+describe Batsir::Notifiers::ConditionalNotifier do
+
+  it_should_behave_like "a notifier", Batsir::Notifiers::ConditionalNotifier
+
+  true_block = ::Proc.new { |message| true }
+
+  let(:notifier){ Batsir::Notifiers::Notifier }
+
+  it "can add notifiers" do
+    subject.notifiers.size.should == 0
+    subject.add_notifier( true_block, notifier)
+    subject.notifiers.size.should == 1
+  end
+
+  it "stores notifier conditions" do
+    subject.add_notifier(true_block, notifier)
+
+    notifier_condition = subject.notifiers.first
+    notifier_condition.should be_a Batsir::Notifiers::ConditionalNotifier::NotifierCondition
+    notifier_condition.condition.should == true_block
+    notifier_condition.notifier.should == notifier
+  end
+
+  it "stores optional options for the notifier" do
+    subject.add_notifier( true_block, notifier, :some => :extra, :options => :foryou)
+
+    notifier_condition = subject.notifiers.first
+    notifier_condition.options.size.should == 2
+    notifier_condition.options.should have_key :some
+    notifier_condition.options.should have_key :options
+  end
+
+  context "sending messages" do
+    class FakeNotifier < Batsir::Notifiers::Notifier; end
+
+    it "executes notifiers if condition is true" do
+
+      notifier_class = FakeNotifier
+      notifier_class.any_instance.stub(:execute)
+      notifier_class.any_instance.should_receive(:execute)
+
+      conditional = Batsir::Notifiers::ConditionalNotifier.new
+      conditional.add_notifier( true_block, notifier_class.new({}) )
+      conditional.execute("some message")
+    end
+
+    it "does not execute when condition is false" do
+      false_block = lambda {|message| false}
+
+      notifier_class = FakeNotifier
+      notifier_class.any_instance.stub(:execute)
+      notifier_class.any_instance.should_not_receive(:execute)
+
+      conditional = Batsir::Notifiers::ConditionalNotifier.new
+      conditional.add_notifier( false_block, notifier_class.new({}) )
+      conditional.execute("some message")
+    end
+  end
+end

data/spec/batsir/notifiers/notifier_spec.rb

@@ -1,73 +1,11 @@
 require File.join( File.dirname(__FILE__), "..", "..",  "spec_helper" )
+require File.join( File.dirname(__FILE__), 'shared_examples')
 
 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_behave_like "a notifier", Batsir::Notifiers::Notifier
 
-  it "should call #execute when #notify is called" do
-    notifier = notifier_class.new
-    notifier.should_receive(:execute)
-    notifier.notify({})
+  it 'raises an error when the #execute method is not implemented' do
+    lambda{ subject.notify({})}.should raise_error NotImplementedError
   end
 end

data/spec/batsir/notifiers/shared_examples.rb

@@ -0,0 +1,100 @@
+shared_examples_for "a notifier" do |notifier_class|
+  before :each do
+    subject{notifier_class.new}
+  end
+
+  context 'transformers' do
+    it "has a transformer_queue" do
+      subject.transformer_queue.should_not be_nil
+    end
+
+    it "initially has an empty transformer_queue" do
+      subject.transformer_queue.should_not be_nil
+      subject.transformer_queue.should be_empty
+    end
+
+    it "can add a transformer to the transformer_queue" do
+      transformer = :transformer
+
+      subject.add_transformer transformer
+
+      subject.transformer_queue.should_not be_empty
+      subject.transformer_queue.size.should == 1
+      subject.transformer_queue.first.should == :transformer
+    end
+
+    it "can add a transformer multiple times" do
+      transformer = :transformer
+
+      subject.add_transformer transformer
+      subject.add_transformer transformer
+
+      subject.transformer_queue.should_not be_empty
+      subject.transformer_queue.size.should == 2
+    end
+
+    it "creates a FieldTransformer when the 'fields' option is given during initialization" do
+      fields = {:foo => :bar}
+      subject = notifier_class.new(:fields => fields)
+      subject.transformer_queue.should_not be_empty
+      subject.transformer_queue.first.class.should == Batsir::Transformers::FieldTransformer
+      subject.transformer_queue.first.fields.should == fields
+    end
+  end
+
+  context 'methods calls' do
+    it "has an #execute method" do
+      notifier_class.instance_methods.map{|m| m.to_s}.should include "execute"
+    end
+
+
+    it "calls #transform when #notify is called" do
+      subject.stub(:execute)
+      subject.should_receive(:transform).with({})
+      subject.notify({})
+    end
+
+    it "calls #transform on all transformers when #transform is called" do
+      class MockTransformer < Batsir::Transformers::Transformer
+      end
+
+      subject.stub(:execute)
+      transformer = MockTransformer.new
+      subject.add_transformer transformer
+      subject.transformer_queue.size.should == 1
+
+      transformer.should_receive(:transform).with({})
+      subject.notify({})
+    end
+
+    it "calls #execute when #notify is called" do
+      subject.stub(:execute)
+      subject.should_receive(:execute)
+      subject.notify({})
+    end
+  end
+
+  context 'message unmodified' do
+    it 'has no transformers' do
+      message = {'test_id' => 123}
+      subject.add_transformer(Batsir::Transformers::JSONOutputTransformer.new)
+      begin
+        subject.notify(message).should == {'test_id' => 123}
+      rescue NotImplementedError => e
+      end
+      message.should == {'test_id' => 123}
+    end
+
+    it 'has a FieldTransformer' do
+      fields = {:foo => 'bar', 'test_id' => 'test'}
+      message = {'test_id' => 123}
+      subject = notifier_class.new(:fields => fields)
+      subject.add_transformer(Batsir::Transformers::JSONOutputTransformer.new)
+      begin
+        subject.notify(message).should == {'test_id' => 123}
+      rescue NotImplementedError => e
+      end
+      message.should == {'test_id' => 123}
+    end
+  end
+end

data/spec/batsir/registry_spec.rb

@@ -0,0 +1,48 @@
+require File.join( File.dirname(__FILE__), "..", "spec_helper" )
+
+describe Batsir::Registry do
+
+  before :all do
+    @class = Batsir::Registry
+  end
+
+  before :each do
+    @class.reset
+  end
+
+  it "outputs the whole registry" do
+    @class.registry.should == {}
+  end
+
+  it "registers a value" do
+    @class.register(:foo, :bar)
+    @class.registry.keys.size.should == 1
+    @class.registry.keys.should include :foo
+    @class.registry.values.size.should == 1
+    @class.registry.values.should include :bar
+  end
+
+  it "is able to retrieve a registered variable" do
+    @class.register('test', 'value')
+    @class.get('test').should == 'value'
+  end
+
+  it "returns nil when the requested key is not found" do
+    @class.get('foobar').should be_nil
+  end
+
+  context "resetting" do
+    it "is possible" do
+      @class.register('foo', 'bar')
+      @class.registry.should == {'foo' => 'bar'}
+      @class.reset
+      @class.registry.should == {}
+    end
+
+    it "returns its new state" do
+      @class.register('foo', 'bar')
+      result = @class.reset
+      result.should == {}
+    end
+  end
+end