queueing_rabbit 0.1.3 → 0.2.0

data/spec/integration/persistent_asynchronous_publishing_and_consuming_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'integration/jobs/print_line_job'
+
+describe "Persistent asynchronous publishing and consuming" do
+  include_context "Evented spec"
+  include_context "StringIO logger"
+
+  before(:all) { QueueingRabbit.client = QueueingRabbit::Client::AMQP }
+  after(:all) { QueueingRabbit.client = QueueingRabbit.default_client }
+
+  context "basic consuming" do
+    let(:line) { "Hello, world!" }
+    let(:connection) { QueueingRabbit.connection }
+    let(:job) {
+      Class.new(PrintLineJob) do
+        queue 'persistent_print_line_job'
+        listen :ack => true
+        publishing_defaults :persistent => true
+        channel :use_publisher_confirms => true
+
+        def perform
+          super
+          acknowledge
+        end
+      end
+    }
+    let(:job_name) { 'PrintLineWithAcknowledgmentsJob' }
+    let(:io) { StringIO.new }
+    let(:worker) { QueueingRabbit::Worker.new(job_name) }
+
+    before(:each) do
+      QueueingRabbit.drop_connection
+    end
+
+    before do
+      stub_const(job_name, job)
+      job.io = io
+    end
+
+    it "processes enqueued jobs" do
+      em {
+        QueueingRabbit.connect
+        @queue_size = nil
+
+        def request_queue_size
+          connection.open_channel do |c, _|
+            connection.define_queue(c, job.queue_name, job.queue_options).status do |s, _|
+              @queue_size = s
+            end
+          end
+        end
+
+        delayed(0.5) {
+          3.times { job.enqueue(line) }
+        }
+
+        delayed(1.5) {
+          request_queue_size
+        }
+
+        delayed(2.0) {
+          @queue_size.should == 3
+        }
+
+        delayed(2.5) {
+          worker.work
+        }
+
+        delayed(3.5) {
+          request_queue_size
+        }
+
+        done(4.0) {
+          @queue_size.should be_zero
+        }
+      }
+    end
+
+    it "actually outputs the line" do
+      em {
+        QueueingRabbit.connect
+
+        delayed(0.5) { job.enqueue(line) }
+
+        delayed(1.0) {
+          worker.work
+        }
+
+        done(2.0) {
+          io.string.should include(line)
+        }
+      }
+    end
+  end
+end
+

data/spec/integration/synchronous_publishing_and_asynchronous_consuming_spec.rb

@@ -10,29 +10,25 @@ describe "Synchronous publishing and asynchronous consuming example" do
 
   after(:all) { QueueingRabbit.client = QueueingRabbit.default_client }
 
-  context "when a message is published synchronously" do
+  context "when a message is published synchronously and being consumed " \
+          "asynchornously" do
+    let(:worker) { QueueingRabbit::Worker.new(job.to_s) }
+    let(:io) { StringIO.new }
+
     before do
-      QueueingRabbit.publish(job, :line => line)
+      job.io = io
+      job.enqueue(line)
       QueueingRabbit.drop_connection
     end
 
-    context "and being consumed asynchornously" do
-      let(:worker) { QueueingRabbit::Worker.new(job.to_s) }
-      let(:io) { StringIO.new }
-
-      before do
-        job.io = io
-      end
-
-      it "works" do
-        em {
-          worker.work
+    it "works" do
+      em {
+        worker.work
 
-          done(1.0) {
-            io.string.should include(line)
-          }
+        done(1.0) {
+          io.string.should include(line)
         }
-      end
+      }
     end
   end
 

data/spec/integration/synchronous_publishing_spec.rb

@@ -6,17 +6,21 @@ describe "Synchronous publishing example" do
 
   let(:job) { PrintLineJob }
 
+  before do
+    job.io = StringIO.new
+  end
+
   context "when publishing a message" do
     after do
       QueueingRabbit.purge_queue(job)
     end
 
     let(:publishing) {
-      lambda { QueueingRabbit.publish(job, :line => "Hello, World!") }
+      Proc.new { job.enqueue("Hello, World!") }
     }
 
     it 'affects the queue size' do
-      expect { 5.times { publishing.call } }.
+      expect { 5.times(&publishing) }.
              to change{QueueingRabbit.queue_size(job)}.by(5)
     end
   end

data/spec/spec_helper.rb

@@ -9,7 +9,6 @@ require 'rspec'
 require 'rspec/autorun'
 require 'evented-spec'
 require 'support/shared_contexts'
-require 'support/shared_examples'
 
 require 'queueing_rabbit'
 
@@ -18,6 +17,10 @@ RSpec.configure do |config|
     QueueingRabbit.drop_connection
   }
 
+  config.exclusion_filter = {
+    :ruby => RUBY_VERSION
+  }
+
   QueueingRabbit.configure do |qr|
     qr.amqp_uri = "amqp://guest:guest@localhost:5672"
     qr.amqp_exchange_name = "queueing_rabbit_test"

data/spec/unit/queueing_rabbit/client/amqp_spec.rb

@@ -19,32 +19,47 @@ describe QueueingRabbit::Client::AMQP do
     its(:connection_options) { should include(:heartbeat) }
     its(:connection_options) { should include(:on_tcp_connection_failure) }
 
-    describe '.run_event_machine' do
+    describe '.ensure_event_machine_is_running' do
       context 'when the event machine reactor is running' do
         before do
           EM.should_receive(:reactor_running?).and_return(true)
         end
 
         it 'has no effect' do
-          subject.run_event_machine
+          subject.ensure_event_machine_is_running
         end
       end
 
       context 'when the event machine reactor is not running' do
         before do
-          EM.should_receive(:reactor_running?).and_return(false)
+          EM.should_receive(:reactor_running?).once.and_return(false)
+          EM.should_receive(:reactor_running?).and_return(true)
           Thread.should_receive(:new).and_yield
           EM.should_receive(:run).and_yield
         end
 
         it 'runs the event machine reactor in a separate thread' do
-          subject.run_event_machine
+          subject.ensure_event_machine_is_running
         end
 
         it 'triggers :event_machine_started event' do
           QueueingRabbit.should_receive(:trigger_event).
                          with(:event_machine_started)
-          subject.run_event_machine
+          subject.ensure_event_machine_is_running
+        end
+      end
+
+      context 'when the event machine can reactor can not be started' do
+        before do
+          EM.should_receive(:reactor_running?).once.and_return(false)
+          EM.should_receive(:reactor_running?).and_raise(Timeout::Error)
+          Thread.should_receive(:new).and_yield
+          EM.should_receive(:run).and_yield
+        end
+
+        it 'raises a QueueingRabbitError after 5 seconds expire' do
+          expect { subject.ensure_event_machine_is_running }.
+              to raise_error(QueueingRabbit::QueueingRabbitError)
         end
       end
     end
@@ -85,98 +100,72 @@ describe QueueingRabbit::Client::AMQP do
       QueueingRabbit::Client::AMQP.stub(:run_event_machine => true)
     end
 
-    it_behaves_like :client
-
     it { should be }
 
     describe '#define_queue' do
-      let(:exchange) { mock }
       let(:channel) { mock }
       let(:queue) { mock }
       let(:queue_name) { "test_queue_name" }
-      let(:routing_keys) { [:test_job] }
-      let(:options) { {:durable => false, :routing_keys => routing_keys} }
+      let(:options) { {:durable => false} }
 
       before do
-        client.stub(:exchange => exchange)
         channel.should_receive(:queue).with(queue_name, options).
                                        and_yield(queue)
-        queue.should_receive(:bind).
-              with(exchange, :routing_key => routing_keys.first.to_s).ordered
-        queue.should_receive(:bind).
-              with(exchange, :routing_key => queue_name).ordered
       end
 
-      it "defines a queue and binds it to its name and the given routing keys" do
+      it "defines a queue" do
         client.define_queue(channel, queue_name, options)
       end
     end
 
     describe '#listen_queue' do
-      let(:channel) { mock }
-      let(:queue_name) { mock }
       let(:options) { mock }
       let(:queue) { mock }
-      let(:metadata) { stub(:ack => true) }
-      let(:data) { {:data => "data"}}
-      let(:payload) { JSON.dump(data) }
+      let(:metadata) { mock }
+      let(:payload) { mock }
 
       before do
-        client.should_receive(:define_queue).
-               with(channel, queue_name, options).and_return(queue)
-        queue.should_receive(:subscribe).
-              with(:ack => true).and_yield(metadata, payload)
+        queue.should_receive(:subscribe).with(options).
+                                         and_yield(metadata, payload)
       end
 
       it 'listens to the queue and passes deserialized arguments to the block' do
-        client.listen_queue(channel, queue_name, options) do |arguments|
-          arguments.should == data
-        end
-      end
-
-      context "when deserialization problems occur" do
-        let(:error) { JSON::JSONError.new }
-        before do
-          client.should_receive(:deserialize).and_raise(error)
-          client.should_receive(:error)
-          client.should_receive(:debug).with(error)
-        end
-
-        it "keeps the record of the errors" do
-          client.listen_queue(channel, queue_name, options)
-        end
-
-        it "silences JSON errors" do
-          expect { client.listen_queue(channel, queue_name, options) }.
-                 to_not raise_error(error)
+        client.listen_queue(queue, options) do |payload, metadata|
+          payload.should == payload
+          metadata.should == metadata
         end
       end
     end
 
     describe '#process_message' do
-      let(:arguments) { mock }
+      let(:payload) { mock }
+      let(:metadata) { mock }
 
       it "yields given arguments to the block" do
-        client.process_message(arguments) do |a|
-          a.should == arguments
+        client.process_message(payload, metadata) do |p, m|
+          p.should == payload
+          m.should == metadata
         end
       end
 
       it "silences all errors risen" do
         expect {
-          client.process_message(arguments) { |a| raise StandardError.new }
+          client.process_message(payload, metadata) do |_, _|
+            raise StandardError.new
+          end
         }.to_not raise_error(StandardError)
       end
 
       context "logging" do
         let(:error) { StandardError.new }
+
         before do
           client.should_receive(:error)
           client.should_receive(:debug).with(error)
         end
 
         it "keeps the record of all errors risen" do
-          client.process_message(arguments) { |a| raise error }
+          client.process_message(payload, metadata) { |_, _| raise error }
         end
       end
     end
@@ -195,7 +184,7 @@ describe QueueingRabbit::Client::AMQP do
 
     describe "#open_channel" do
       let(:next_channel_id) { mock }
-      let(:options) { mock }
+      let(:options) { {:use_publisher_confirms => true} }
       let(:channel) { mock }
       let(:open_ok) { mock }
 
@@ -206,6 +195,7 @@ describe QueueingRabbit::Client::AMQP do
                       with(connection, next_channel_id, options).
                       and_yield(channel, open_ok)
         channel.should_receive(:on_error)
+        channel.should_receive(:confirm_select)
       end
 
       it 'opens a new AMQP channel with given options and installs ' \
@@ -213,5 +203,44 @@ describe QueueingRabbit::Client::AMQP do
         client.open_channel(options) {}
       end
     end
+
+    describe '#define_exchange' do
+      context 'when only channel is given' do
+        let(:channel) { mock }
+        let(:default_exchange) { mock }
+
+        before do
+          channel.should_receive(:default_exchange).and_return(default_exchange)
+        end
+
+        it 'returns the default exchange' do
+          client.define_exchange(channel).should == default_exchange
+        end
+      end
+
+      context 'with arguments and type' do
+        let(:channel) { mock }
+        let(:name) { 'some_exchange_name' }
+        let(:options) { {:type => 'direct'} }
+        let(:exchange) { mock }
+
+        it 'creates an exchange of given type and options' do
+          channel.should_receive(:direct).with(name, options).
+                                          and_return(exchange)
+          client.define_exchange(channel, name, options).should == exchange
+        end
+      end
+    end
+
+    describe '#enqueue' do
+      let(:exchange) { mock }
+      let(:payload) { mock }
+      let(:options) { mock }
+
+      it "publishes a new message to given exchange with given options" do
+        exchange.should_receive(:publish).with(payload, options)
+        client.enqueue(exchange, payload, options)
+      end
+    end
   end
 end

data/spec/unit/queueing_rabbit/client/bunny_spec.rb

@@ -32,20 +32,19 @@ describe QueueingRabbit::Client::Bunny do
       Bunny.stub(:new => connection)
     end
 
-    it_behaves_like :client
-
     it { should be }
 
     describe '#open_channel' do
-      let(:options) { mock }
+      let(:options) { {:use_publisher_confirms => true} }
       let(:channel) { mock }
 
       before do
         connection.should_receive(:create_channel).and_return(channel)
+        channel.should_receive(:confirm_select)
       end
 
       it 'creates a channel and yields it' do
-        client.open_channel do |c, _|
+        client.open_channel(options) do |c, _|
           c.should == channel
         end
       end
@@ -54,16 +53,22 @@ describe QueueingRabbit::Client::Bunny do
     describe '#define_queue' do
       let(:channel) { mock }
       let(:queue) { mock }
-      let(:exchange) { mock }
       let(:name) { 'queue_name_test' }
       let(:options) { {:foo => 'bar'} }
 
       it 'creates a queue and binds it to the global exchange' do
         channel.should_receive(:queue).with(name, options).and_return(queue)
-        client.should_receive(:exchange).with(channel).and_return(exchange)
-        queue.should_receive(:bind).with(exchange, :routing_key => name)
+        client.define_queue(channel, name, options).should == queue
+      end
+
+      context 'when block is given' do
+        it 'yields the created queue' do
+          channel.should_receive(:queue).with(name, options).and_return(queue)
 
-        client.define_queue(channel, name, options)
+          client.define_queue(channel, name, options) do |q|
+            q.should == queue
+          end
+        end
       end
     end
 
@@ -80,5 +85,45 @@ describe QueueingRabbit::Client::Bunny do
       end
     end
 
+    describe '#define_exchange' do
+      context 'when only channel is given' do
+        let(:channel) { mock }
+        let(:default_exchange) { mock }
+
+        before do
+          channel.should_receive(:default_exchange).
+                  and_return(default_exchange)
+        end
+
+        it 'returns the default exchange' do
+          client.define_exchange(channel).should == default_exchange
+        end
+      end
+
+      context 'with arguments and type' do
+        let(:channel) { mock }
+        let(:name) { 'some_exchange_name' }
+        let(:options) { {:type => 'direct'} }
+        let(:exchange) { mock }
+
+        it 'creates an exchange of given type and options' do
+          channel.should_receive(:direct).with(name, options).
+                                          and_return(exchange)
+          client.define_exchange(channel, name, options).should == exchange
+        end
+      end
+    end
+
+    describe '#enqueue' do
+      let(:exchange) { mock }
+      let(:payload) { mock }
+      let(:options) { mock }
+
+      it "publishes a new message to given exchange with given options" do
+        exchange.should_receive(:publish).with(payload, options)
+        client.enqueue(exchange, payload, options)
+      end
+    end
+
   end
 end