dispatch-rider 1.4.0 → 1.4.2

data/spec/lib/dispatch-rider/dispatcher_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe DispatchRider::Dispatcher, :nodb => true do
+  class HandleSomething < DispatchRider::Handlers::Base
+    def process(params)
+      throw :something if params[:do_throw_something]
+    end
+  end
+
+  class HandlerThatReturnsFalse < DispatchRider::Handlers::Base
+    def process(params)
+      false
+    end
+  end
+
+  describe "#dispatch" do
+    let(:message){ DispatchRider::Message.new(:subject => "handle_something", :body => { :do_throw_something => true }) }
+
+    describe "callbacks" do
+      let(:dummy) { double(:dummy) }
+      let(:storage) { DispatchRider::Callbacks::Storage.new }
+      let(:message){ DispatchRider::Message.new(:subject => "handle_something", :body => { :do_throw_something => true }) }
+
+      before do
+        DispatchRider.config.stub(:callbacks) { storage }
+        storage.around(:dispatch_message) do |block, message|
+          begin
+            dummy.before
+            dummy.log(message)
+            block.call
+          ensure
+            dummy.after
+          end
+        end
+        subject.register('handle_something')
+      end
+      example do
+        dummy.should_receive(:before).once
+        dummy.should_receive(:after).once
+        dummy.should_receive(:log).with(message).once
+        catch(:something) do
+          subject.dispatch(message)
+        end
+      end
+    end
+
+    context "when the handler provided in the message is present" do
+      before :each do
+        subject.register('handle_something')
+      end
+
+      it "should process the message" do
+        expect { subject.dispatch(message) }.to throw_symbol(:something)
+      end
+    end
+
+    context "when the handler returns false" do
+      let(:message){ DispatchRider::Message.new(:subject => "handler_that_returns_false", :body => { :do_throw_something => true }) }
+
+      before :each do
+        subject.register('handler_that_returns_false')
+      end
+
+      it "should return true indicating message is good to be removed" do
+        expect(subject.dispatch(message)).to be true
+      end
+    end
+  end
+end

data/spec/lib/dispatch-rider/handlers/base_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe DispatchRider::Handlers::Base do
+  class NoProcessImplemented < DispatchRider::Handlers::Base
+  end
+
+  class ProcessImplemented < DispatchRider::Handlers::Base
+    def process(options)
+      "good job"
+    end
+  end
+  
+  class ProcessWithImmediateRetry < DispatchRider::Handlers::Base
+    def process(options)
+      raise "I have failed!"
+    end
+    
+    def retry_timeout; :immediate; end
+  end
+  
+  class ProcessWithTenSecondRetry < DispatchRider::Handlers::Base
+    def process(options)
+      raise "I have failed!"
+    end
+    
+    def retry_timeout; 10*60; end
+  end
+
+  describe "#do_process" do
+    let(:message){ double(:message, subject: 'some_message', body: { 'guid' => DispatchRider::Debug::PUBLISHER_MESSAGE_GUID }) }
+
+    context "when class doesn't implement process" do
+      let(:handler){ NoProcessImplemented.new }
+
+      example do
+        expect {
+          handler.do_process(message)
+        }.to raise_exception NotImplementedError, "Method 'process' not overridden in subclass!"
+      end
+    end
+
+    context "when the class does implement process" do
+      let(:handler){ ProcessImplemented.new }
+
+      example do
+        expect {
+          handler.do_process(message)
+        }.to_not raise_exception
+      end
+
+      example do
+        handler.do_process(message).should == "good job"
+      end
+    end
+    
+    context "when the class wants to immediately retry" do
+      let(:handler) { ProcessWithImmediateRetry.new }
+      
+      example do
+        message.should_receive(:return_to_queue)
+        
+        expect {
+          handler.do_process(message)
+        }.to raise_exception "I have failed!"
+      end
+    end
+    
+    context "when the class wants to retry in 10 seconds" do
+      let(:handler) { ProcessWithTenSecondRetry.new }
+      
+      example do
+        message.should_receive(:extend_timeout).with(10*60)
+        
+        expect {
+          handler.do_process(message)
+        }.to raise_exception "I have failed!"
+      end
+    end
+  end
+
+end

data/spec/lib/dispatch-rider/handlers/inheritance_tracking_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe DispatchRider::Handlers::InheritanceTracking do
+
+  class InheritanceDummyClass
+    extend DispatchRider::Handlers::InheritanceTracking
+  end
+
+  describe ".subclasses" do
+    context "when a class inherits from the dummy class" do
+      class Blah < InheritanceDummyClass; end
+
+      example do
+        InheritanceDummyClass.subclasses.should include(Blah)
+      end
+
+      context "and another class inherits from the dummy class" do
+        class Foo < InheritanceDummyClass; end
+
+        example do
+          InheritanceDummyClass.subclasses.should include(Blah, Foo)
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/dispatch-rider/message_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe DispatchRider::Message do
+  subject(:message) {DispatchRider::Message.new(:subject => 'test', :body => 'test_handler')}
+
+  describe "#initialize" do
+    context "when all the required attributes are passed" do
+      context "when the attributes hash has keys as strings" do
+        subject(:message) {DispatchRider::Message.new('subject' => 'test', 'body' => 'test_handler')}
+
+        it "should initiate a new message" do
+          message.subject.should eq('test')
+          message.body.should eq('test_handler')
+        end
+      end
+
+      context "when the attributes hash has keys as symbols" do
+        it "should initiate a new message" do
+          message.subject.should eq('test')
+          message.body.should eq('test_handler')
+        end
+      end
+    end
+
+    context "when all the required attributes are not passed" do
+      it "should raise an exception" do
+        expect { DispatchRider::Message.new({}) }.to raise_exception(DispatchRider::RecordInvalid)
+      end
+    end
+  end
+
+  describe "#attributes" do
+    it "should return the attributes hash of the message" do
+      message.attributes.should eq({:subject => 'test', :body => 'test_handler'})
+    end
+  end
+
+  describe "#to_json" do
+    it "should return the attributes hash in json format" do
+      result = JSON.parse(message.to_json)
+      result['subject'].should eq('test')
+      result['body'].should eq('test_handler')
+    end
+  end
+
+  describe "#==" do
+    context "when 2 messages have the same attribute values" do
+      it "should return true" do
+        message.should eq(DispatchRider::Message.new(:subject => 'test', :body => 'test_handler'))
+      end
+    end
+
+    context "when 2 messages do not have same attribute values" do
+      it "should return false" do
+        message.should_not eq(DispatchRider::Message.new(:subject => 'random_test', :body => 'test_handler'))
+      end
+    end
+  end
+end

data/spec/lib/dispatch-rider/notification_services/aws_sns_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe DispatchRider::NotificationServices::AwsSns do
+  let(:amazon_resource_name){ "arn:aws:sns:us-west-2:123456789012:GeneralTopic" }
+
+  describe "#notifier_builder" do
+    it "returns the notifier builder" do
+      subject.notifier_builder.should eq(AWS::SNS)
+    end
+  end
+
+  describe "#channel_registrar_builder" do
+    it "returns the channel registrar builder" do
+      subject.channel_registrar_builder.should eq(DispatchRider::Registrars::SnsChannel)
+    end
+  end
+
+  describe "#channel" do
+    before { subject.stub(:channel_registrar).and_return(foo: amazon_resource_name) }
+
+    let(:topics){ double :sns_topics }
+    let(:topic){ double :sns_topic }
+
+    it "returns the channel" do
+      subject.channel(:foo).arn.should == amazon_resource_name
+    end
+  end
+end

data/spec/lib/dispatch-rider/notification_services/base_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe DispatchRider::NotificationServices::Base do
+  let :channel do
+    channel = OpenStruct.new
+    class << channel
+      def publish(msg)
+        throw :published, JSON.parse(msg)["body"]["bar"]
+      end
+    end
+    channel
+  end
+
+  before :each do
+    DispatchRider::NotificationServices::Base.any_instance.stub(:notifier_builder).and_return(OpenStruct)
+    DispatchRider::NotificationServices::Base.any_instance.stub(:channel_registrar_builder).and_return(DispatchRider::Registrars::SnsChannel)
+    DispatchRider::NotificationServices::Base.any_instance.stub(:channel) do |name|
+      subject.notifier.topics[subject.fetch(name)] if name == :foo
+    end
+  end
+
+  subject do
+    DispatchRider::NotificationServices::Base.new({:topics => {}})
+  end
+
+  describe "#initialize" do
+    it "assigns the notifier" do
+      subject.notifier.should respond_to(:topics)
+    end
+
+    it "assigns the channel registrar" do
+      subject.channel_registrar.store.should be_empty
+    end
+  end
+
+  describe "#publish" do
+    before :each do
+      subject.register(:foo, account: 123, region: "us-east-1", topic: "PlanOfAttack")
+      subject.notifier.topics['arn:aws:sns:us-east-1:123:PlanOfAttack'] = channel
+    end
+
+    it "publishes the message to the channels" do
+      catch :published do
+        subject.publish(:to => :foo, :message => {:subject => :test_handler, :body => {"bar" => "baz"}})
+      end.should eq('baz')
+    end
+  end
+
+  describe "#channels" do
+    before :each do
+      subject.register(:foo, account: 123, region: "us-east-1", topic: "PlanOfAttack")
+      subject.notifier.topics['arn:aws:sns:us-east-1:123:PlanOfAttack'] = channel
+    end
+
+    it "returns an array of channels" do
+      subject.channels(:foo).should eq([channel])
+    end
+  end
+
+  describe "#message_builder" do
+    it "should return the message builder class" do
+      subject.message_builder.should eq(DispatchRider::Message)
+    end
+  end
+end

data/spec/lib/dispatch-rider/notification_services/file_system/channel_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe DispatchRider::NotificationServices::FileSystem::Channel do
+
+  let(:path) { File.expand_path("tmp/test/channel") }
+  let(:published_message) { File.new(Dir["#{path}/*.ready"].first).read }
+
+  before { FileUtils.mkdir_p(path) }
+  after { FileUtils.rm_rf(path) }
+
+  subject { described_class.new(path) }
+
+  describe "#publish" do
+    let(:message){ {:subject => "foo", :body => "bar"}.to_json }
+
+    it "adds a file to the path folder" do
+      expect {
+        subject.publish(message)
+      }.to change { Dir["#{path}/*"].length }.by(1)
+    end
+
+    it "writes the message to the file" do
+      subject.publish(message)
+
+      published_message.should == message
+    end
+  end
+end

data/spec/lib/dispatch-rider/notification_services/file_system/notifier_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe DispatchRider::NotificationServices::FileSystem::Notifier do
+
+  subject { described_class.new({}) }
+
+  describe "#channel" do
+    it "returns a channel object" do
+      subject.channel("tmp/some/path").should be_a(DispatchRider::NotificationServices::FileSystem::Channel)
+    end
+  end
+
+end
+

data/spec/lib/dispatch-rider/notification_services/file_system_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe DispatchRider::NotificationServices::FileSystem do
+
+  describe "#notifier_builder" do
+    it "returns the notifier builder" do
+      subject.notifier_builder.should eq(DispatchRider::NotificationServices::FileSystem::Notifier)
+    end
+  end
+
+  describe "#channel_registrar_builder" do
+    it "returns the channel registrar builder" do
+      subject.channel_registrar_builder.should eq(DispatchRider::Registrars::FileSystemChannel)
+    end
+  end
+
+  describe "#channel" do
+    it "returns the channel" do
+      subject.channel_registrar.register(:foo, :path => "tmp/test/channel")
+      subject.channel(:foo).should be_a(DispatchRider::NotificationServices::FileSystem::Channel)
+    end
+  end
+end

data/spec/lib/dispatch-rider/notification_services_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe DispatchRider::NotificationServices do
+end

data/spec/lib/dispatch-rider/publisher/base_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe DispatchRider::Publisher::Base do
+
+  class DummyPublisher < DispatchRider::Publisher::Base
+    destinations [:sns_message_queue, :file_system_queue]
+    subject "Loud Cheering"
+
+    def self.publish(cheer)
+      new.publish(cheer)
+    end
+  end
+
+  class DummyCustomPublisher < DispatchRider::Publisher::Base
+    destinations :sqs_message_queue
+    subject "Ferocious Tigers!"
+
+    def self.publish(body, publisher)
+      new(publisher).publish(body)
+    end
+  end
+
+  describe ".default_publisher" do
+    example do
+      described_class.default_publisher.should be_a(DispatchRider::Publisher)
+    end
+  end
+
+  describe ".publish" do
+    context "in the base class" do
+      example do
+        expect {
+          described_class.publish
+        }.to raise_error NotImplementedError
+      end
+    end
+
+    context "in a derived class with publish implemented" do
+      let(:message) do
+        {
+          destinations: [:sns_message_queue, :file_system_queue],
+          message: {
+            subject: "Loud Cheering",
+            body: {
+              "bla" => "WOOOOOOOO!",
+            }
+          }
+        }
+      end
+
+      example do
+        DummyPublisher.default_publisher.should_receive(:publish).with(message)
+        DummyPublisher.publish({"bla" => "WOOOOOOOO!"})
+      end
+    end
+
+    context "in a derived class with publish implemented and a custom publisher" do
+      let(:message) do
+        {
+          destinations: [:sqs_message_queue],
+          message: {
+            subject: "Ferocious Tigers!",
+            body: {
+              "bla" => "RAAAAAWWWWW!",
+            },
+          }
+        }
+      end
+
+      let(:publisher) { double(:publisher) }
+
+      example do
+        publisher.should_receive(:publish).with(message)
+        DummyCustomPublisher.publish({"bla" => "RAAAAAWWWWW!"}, publisher)
+      end
+    end
+  end
+
+end