dispatch-rider 1.4.0 → 1.4.2

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe DispatchRider::QueueServices::FileSystem do
+  let(:queue_path) { "tmp/queue" }
+
+  subject(:file_system_queue) do
+    DispatchRider::QueueServices::FileSystem.new(:path => queue_path)
+  end
+
+  before { file_system_queue.send(:queue).send(:file_paths).each{|file| File.unlink(file)} }
+
+  describe "#assign_storage" do
+    it "should return an empty array" do
+      file_system_queue.assign_storage({:path => queue_path}).should be_a DispatchRider::QueueServices::FileSystem::Queue
+    end
+  end
+
+  describe "#insert" do
+    it "should insert a serialized object into the queue" do
+      file_system_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
+      result = JSON.parse(file_system_queue.queue.pop.read)
+      result['subject'].should eq('foo')
+      result['body'].should eq('bar')
+    end
+  end
+
+  describe "#raw_head" do
+    before :each do
+      file_system_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
+    end
+
+    it "should return the first item from the queue" do
+      result = JSON.parse(file_system_queue.raw_head.read)
+      result['subject'].should eq('foo')
+      result['body'].should eq('bar')
+    end
+  end
+
+  describe "#construct_message_from" do
+    let(:new_file) do
+      file = Tempfile.new('item')
+      file.write({'subject' => 'foo', 'body' => 'bar'}.to_json)
+      file.rewind
+      file
+    end
+
+    it "should return the item casted as a message" do
+      result = file_system_queue.construct_message_from(new_file)
+      result.subject.should eq('foo')
+      result.body.should eq('bar')
+    end
+  end
+  
+  describe "#put_back" do
+    before :each do
+      file_system_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
+    end
+    
+    it "should remove and re-add the item" do
+      file = file_system_queue.raw_head
+      file_system_queue.should be_empty
+      file_system_queue.put_back(file)
+      file_system_queue.size.should eq(1)
+    end
+  end
+
+  describe "#delete" do
+    before :each do
+      file_system_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
+    end
+
+    it "should remove the item from the queue" do
+      file = File.new(Dir["#{queue_path}/*.ready"].first, "w")
+      file_system_queue.delete(file)
+      file_system_queue.should be_empty
+    end
+  end
+
+  describe "#size" do
+    before :each do
+      file_system_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
+    end
+
+    it "should return the size of the queue" do
+      file_system_queue.size.should eq(1)
+    end
+  end
+end

data/spec/lib/dispatch-rider/queue_services/received_message_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe DispatchRider::QueueServices::ReceivedMessage do
+
+  subject{ described_class.new("test_message", double(:item)) }
+
+  describe "#extend_timeout" do
+    example do
+      expect{
+        subject.extend_timeout(10)
+      }.to raise_error NotImplementedError
+    end
+  end
+
+  describe "#return_to_queue" do
+    example do
+      expect{
+        subject.return_to_queue
+      }.to raise_error NotImplementedError
+    end
+  end
+
+end

data/spec/lib/dispatch-rider/queue_services/simple_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe DispatchRider::QueueServices::Simple do
+  subject(:simple_queue) do
+    DispatchRider::QueueServices::Simple.new
+  end
+
+  describe "#assign_storage" do
+    it "should return an empty array" do
+      simple_queue.assign_storage({}).should eq([])
+    end
+  end
+
+  describe "#insert" do
+    it "should insert a serialized object into the queue" do
+      simple_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
+      result = JSON.parse(simple_queue.queue.pop)
+      result['subject'].should eq('foo')
+      result['body'].should eq('bar')
+    end
+  end
+
+  describe "#raw_head" do
+    before :each do
+      simple_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
+    end
+
+    it "should return the first item from the queue" do
+      result = JSON.parse(simple_queue.raw_head)
+      result['subject'].should eq('foo')
+      result['body'].should eq('bar')
+    end
+  end
+
+  describe "#construct_message_from" do
+    it "should return the item casted as a message" do
+      result = simple_queue.construct_message_from({'subject' => 'foo', 'body' => 'bar'}.to_json)
+      result.subject.should eq('foo')
+      result.body.should eq('bar')
+    end
+  end
+
+  describe "#delete" do
+    before :each do
+      simple_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
+    end
+
+    it "should remove the item from the queue" do
+      simple_queue.delete({'subject' => 'foo', 'body' => 'bar'}.to_json)
+      simple_queue.should be_empty
+    end
+  end
+
+  describe "#size" do
+    before :each do
+      simple_queue.insert({'subject' => 'foo', 'body' => 'bar'}.to_json)
+    end
+
+    it "should return the size of the queue" do
+      simple_queue.size.should eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe DispatchRider::QueueServices do
+  it "should work" do
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe DispatchRider::Registrars::Base do
+  subject do
+    described_class.new
+  end
+
+  describe "#initialize" do
+    it "assigns store" do
+      subject.store.should be_empty
+    end
+  end
+
+  describe "#register" do
+    it "registers the value" do
+      subject.should_receive(:value).with(:foo, {}).and_return("bar")
+      subject.register(:foo)
+      subject.fetch(:foo).should eq('bar')
+    end
+
+    it "should return the registrar" do
+      subject.should_receive(:value).with(:foo, {}).and_return("bar")
+      subject.register(:foo).should eq(subject)
+    end
+
+    context "when there is a missing constant while registering" do
+      it "raises an exception" do
+        subject.should_receive(:value).with(:foo, {}) { 'bar'.camelize.constantize }
+        expect { subject.register(:foo) }.to raise_exception(DispatchRider::NotFound)
+      end
+    end
+  end
+
+  describe "#unregister" do
+    before :each do
+      subject.stub(:value).and_return('bar')
+      subject.register(:foo)
+    end
+
+    it "unregisters the key/value pair from the registrar" do
+      subject.unregister(:foo)
+      expect { subject.fetch(:foo) }.to raise_exception(DispatchRider::NotRegistered)
+    end
+
+    it "returns the registrar" do
+      subject.unregister(:foo).should eq(subject)
+    end
+  end
+
+  describe "#fetch" do
+    context "when a key/value pair is registered" do
+      before :each do
+        subject.stub(:value).and_return('bar')
+        subject.register(:foo)
+      end
+
+      it "return the value for the key" do
+        subject.fetch(:foo).should eq('bar')
+      end
+    end
+
+    context "when a key/value pair is not registered" do
+      it "raises an exception" do
+        expect { subject.fetch(:foo) }.to raise_exception(DispatchRider::NotRegistered)
+      end
+    end
+  end
+end

data/spec/lib/dispatch-rider/registrars/file_system_channel_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe DispatchRider::Registrars::FileSystemChannel do
+  describe "#value" do
+    let(:path){ "/foo/bar" }
+    let(:channel_options){ {path: path} }
+
+    it "returns the expanded path from the options" do
+      subject.value(:foo, channel_options).should eq("/foo/bar")
+    end
+  end
+end

data/spec/lib/dispatch-rider/registrars/handler_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe DispatchRider::Registrars::Handler do
+  module CustomTestHandler
+  end
+
+  subject do
+    described_class.new
+  end
+
+  describe "#value" do
+    it "returns the value for the key/value pair while registering a handler" do
+      subject.value(:custom_test_handler).should eq(CustomTestHandler)
+    end
+  end
+end

data/spec/lib/dispatch-rider/registrars/notification_service_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe DispatchRider::Registrars::NotificationService do
+  subject do
+    described_class.new
+  end
+
+  describe "#value" do
+    it "returns the value for the key/value pair while registering a notification service" do
+      subject.value(:aws_sns).should be_a(DispatchRider::NotificationServices::AwsSns)
+    end
+  end
+end

data/spec/lib/dispatch-rider/registrars/publishing_destination_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe DispatchRider::Registrars::PublishingDestination do
+  describe "#value" do
+    it "returns an object which has information about a notification service and a channel" do
+      result = subject.value('foo', :service => :aws_sns, :channel => :bar)
+      result.service.should eq(:aws_sns)
+      result.channel.should eq(:bar)
+    end
+  end
+end

data/spec/lib/dispatch-rider/registrars/queue_service_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe DispatchRider::Registrars::QueueService do
+  subject do
+    described_class.new
+  end
+
+  describe "#value" do
+    it "returns the value for the key/value pair while registering a queue service" do
+      subject.value(:simple).should be_a(DispatchRider::QueueServices::Simple)
+    end
+  end
+end

data/spec/lib/dispatch-rider/registrars/sns_channel_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe DispatchRider::Registrars::SnsChannel do
+  describe "#value" do
+    let(:account){ "123456789012" }
+    let(:region){ "us-west-2" }
+    let(:topic_name){ "GeneralTopic" }
+    let(:channel_options){ {account: account, region: region, topic: topic_name} }
+
+    it "returns the value for the key/value pair while registering an amazon sns channel" do
+      subject.value(:foo, channel_options).should eq("arn:aws:sns:us-west-2:123456789012:GeneralTopic")
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe DispatchRider::Runner do
+
+  describe ".run" do
+    let(:subscriber){ double(:subscriber) }
+
+    before :each do
+      DispatchRider.configure do |config|
+        config.subscriber = subscriber
+      end
+    end
+
+    example do
+      subscriber.should_receive(:new).once.and_return(subscriber)
+      subscriber.should_receive(:register_queue).once
+      subscriber.should_receive(:setup_demultiplexer).once
+      subscriber.should_receive(:process).once
+      subscriber.stub(:register_handler)
+
+      described_class.run
+    end
+  end
+
+end

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

@@ -0,0 +1,140 @@
+require "spec_helper"
+
+describe DispatchRider::Subscriber do
+
+  before do
+    DispatchRider::Handlers::Base.stub(:subclasses){ Set.new }
+
+    stub_const("FooBar", Class.new(DispatchRider::Handlers::Base) {
+      def process(options)
+        throw :process_was_called
+      end
+    })
+  end
+
+  describe "#initialize" do
+    it "should assign a new queue service registrar" do
+      subject.queue_service_registrar.store.should be_empty
+    end
+  end
+
+  describe "#register_queue" do
+    it "should register a queue service with the queue service registrar" do
+      subject.register_queue(:simple)
+      subject.queue_service_registrar.fetch(:simple).should be_empty
+    end
+  end
+
+  describe "#register_handler" do
+    it "should register a handler" do
+      subject.register_handler(:foo_bar)
+      expect { subject.dispatcher.dispatch(DispatchRider::Message.new(:subject => :foo_bar, :body => {'foo' => 'bar'})) }.to throw_symbol(:process_was_called)
+    end
+  end
+
+  describe "#register_handlers" do
+    it "should register all the handlers" do
+      subject.register_handlers(:foo_bar)
+      expect { subject.dispatcher.dispatch(DispatchRider::Message.new(:subject => :foo_bar, :body => {'foo' => 'bar'})) }.to throw_symbol(:process_was_called)
+    end
+  end
+
+  describe "#setup_demultiplexer" do
+    context "when a queue is registered" do
+      before :each do
+        subject.register_queue(:simple)
+        subject.register_handler(:foo_bar)
+      end
+
+      it "should assign a demultiplexer" do
+        subject.setup_demultiplexer(:simple)
+        subject.demultiplexer.queue.should be_empty
+        subject.demultiplexer.dispatcher.fetch(:foo_bar).should eq(FooBar)
+      end
+    end
+  end
+
+  describe "#process" do
+    before :each do
+      subject.register_queue(:simple)
+      subject.register_handler(:foo_bar)
+      subject.setup_demultiplexer(:simple)
+    end
+
+    describe "processing" do
+      before do
+        subject.queue_service_registrar.fetch(:simple).push(DispatchRider::Message.new(subject: :foo_bar, body: {'baz' => 'blah'}))
+      end
+
+      it "should process the queue" do
+        expect { subject.process }.to throw_symbol(:process_was_called)
+      end
+    end
+
+    # kills travis sometimes so leaving it here as tested documentation
+    describe "process termination", if: false do
+      before { subject.demultiplexer.stub(:stop){ throw :got_stopped } }
+
+      context "when process quits" do
+        before do
+          stub_const("Quiter", Class.new(DispatchRider::Handlers::Base) {
+            def process(options)
+              Process.kill("QUIT", 0)
+            end
+          })
+
+          subject.register_handler(:quiter)
+          subject.queue_service_registrar.fetch(:simple).push(DispatchRider::Message.new(subject: :quiter, body: {}))
+        end
+
+        example { expect { subject.process }.to throw_symbol(:got_stopped) }
+      end
+
+      context "when process terminates" do
+        before do
+          stub_const("Terminator", Class.new(DispatchRider::Handlers::Base) {
+            def process(options)
+              Process.kill("TERM", 0)
+            end
+          })
+          subject.register_handler(:terminator)
+          subject.queue_service_registrar.fetch(:simple).push(DispatchRider::Message.new(subject: :terminator, body: {}))
+        end
+
+        example { expect { subject.process }.to throw_symbol(:got_stopped) }
+      end
+
+      context "when process is interupted" do
+        before do
+          stub_const("Interupter", Class.new(DispatchRider::Handlers::Base) {
+            def process(options)
+              Process.kill("INT", 0)
+            end
+          })
+          subject.register_handler(:interupter)
+          subject.queue_service_registrar.fetch(:simple).push(DispatchRider::Message.new(subject: :interupter, body: {}))
+        end
+
+        example { expect { subject.process }.to throw_symbol(:got_stopped) }
+      end
+
+      context "when process is interupted twice" do
+        before do
+          subject.demultiplexer.stub(:stop) # do nothing just ignore the interuption
+          subject.stub(:exit){ throw :got_forcefully_stopped }
+
+          stub_const("TwiceInterupter", Class.new(DispatchRider::Handlers::Base) {
+            def process(options)
+              2.times { Process.kill("INT", 0) }
+            end
+          })
+          subject.register_handler(:twice_interupter)
+          subject.queue_service_registrar.fetch(:simple).push(DispatchRider::Message.new(subject: :twice_interupter, body: {}))
+        end
+
+        example { expect { subject.process }.to throw_symbol(:got_forcefully_stopped) }
+      end
+    end
+  end
+
+end