queueing_rabbit 0.1.3 → 0.2.0

data/spec/unit/queueing_rabbit/extensions/direct_exchange_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe QueueingRabbit::JobExtensions::DirectExchange do
+
+  let(:test_job) {
+    Class.new(QueueingRabbit::AbstractJob) do
+      include QueueingRabbit::JobExtensions::DirectExchange
+
+      exchange 'test_job'
+      queue 'test_queue'
+    end
+  }
+
+  subject { test_job }
+
+  its(:exchange_name) { should == 'test_job' }
+  its(:exchange_options) { should include(:type => :direct) }
+  its(:binding_options) { should include(:routing_key => 'test_queue') }
+
+end

data/spec/unit/queueing_rabbit/extensions/new_relic_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe QueueingRabbit::JobExtensions::NewRelic do
+  let(:installation) {
+    Proc.new do
+      job.class_eval { include QueueingRabbit::JobExtensions::NewRelic }
+    end
+  }
+  let(:new_relic) { Module.new }
+
+  before do
+    stub_const('NewRelic::Agent::Instrumentation::ControllerInstrumentation',
+               new_relic)
+  end
+
+  context 'when is being installed into an instantiated job' do
+    let(:job) { Class.new(QueueingRabbit::AbstractJob) }
+
+    it 'registers a transaction tracer' do
+      job.should_receive(:add_transaction_tracer).
+          with(:perform, :category => :task)
+      installation.call
+    end
+  end
+
+  # Don't know how to get this test working on Ruby 1.8.7
+  context 'when is being installed into a class based job', :ruby => '1.8.7' do
+    let(:job) { Class.new { def self.perform; end } }
+
+    it 'registers a transaction tracer' do
+      job.class.should_receive(:add_transaction_tracer).
+          with(:perform, :category => :task)
+      installation.call
+    end
+  end
+end

data/spec/unit/queueing_rabbit/extensions/retryable_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe QueueingRabbit::JobExtensions::Retryable do
+
+  let(:test_job) {
+    Class.new(QueueingRabbit::AbstractJob) do
+      include QueueingRabbit::JobExtensions::Retryable
+
+      exchange 'test_job'
+      queue 'test_queue'
+
+      def perform
+      end
+    end
+  }
+  let(:payload) { mock }
+  let(:headers) { {'qr_retries' => 2} }
+  let(:metadata) { mock(:headers => headers)}
+
+  subject { test_job.new(payload, metadata) }
+
+  its(:retries) { should == 2 }
+
+  describe '#retry_upto' do
+    it 'returns nil and does not retry if attempts exceeded' do
+      subject.retry_upto(2).should_not be
+    end
+
+    it 'retries with increased number of attempts' do
+      test_job.should_receive(:enqueue).
+               with(payload, :headers => {'qr_retries' => 3}).and_return(true)
+      subject.retry_upto(3).should be_true
+    end
+  end
+
+end

data/spec/unit/queueing_rabbit/job_spec.rb

@@ -1,15 +1,39 @@
 require 'spec_helper'
 
 describe QueueingRabbit::AbstractJob do
-  subject { QueueingRabbit::AbstractJob }
-  
+  let(:job_class) {
+    Class.new(QueueingRabbit::AbstractJob) do
+      queue 'test_queue', :durable => true
+      exchange 'test_exchange', :durable => false
+      bind :routing_key => 'test.*'
+    end
+  }
+
+  subject { job_class }
+
+  it { should respond_to(:exchange).with(1).argument }
+  it { should respond_to(:exchange).with(2).arguments }
+  it { should respond_to(:exchange_name) }
+  it { should respond_to(:exchange_options) }
+  it { should respond_to(:queue).with(1).argument }
   it { should respond_to(:queue).with(2).arguments }
   it { should respond_to(:queue_name) }
   it { should respond_to(:queue_options) }
   it { should respond_to(:channel_options) }
   it { should respond_to(:channel).with(1).argument }
+  it { should respond_to(:enqueue).with(1).argument }
+  it { should respond_to(:enqueue).with(2).arguments }
+  it { should respond_to(:listening_options) }
+  it { should respond_to(:listen) }
+  it { should respond_to(:listen).with(1).argument }
+  it { should respond_to(:publishing_defaults) }
+  it { should respond_to(:publishing_defaults).with(1).argument }
 
-  its(:queue_name) { should == 'AbstractJob' }
+  its(:queue_name) { should == 'test_queue' }
+  its(:queue_options) { should include(:durable => true) }
+  its(:exchange_options) { should include(:durable => false) }
+  its(:binding_options) { should include(:routing_key => 'test.*') }
+  its(:publishing_defaults) { should include(:routing_key => 'test_queue') }
 
   describe ".queue_size" do
     let(:size) { mock }
@@ -20,4 +44,52 @@ describe QueueingRabbit::AbstractJob do
 
     its(:queue_size) { should == size }
   end
-end
+
+  describe '.enqueue' do
+    let(:payload) { mock }
+    let(:options) { {:persistent => true} }
+    let(:result_options) { options.merge(job_class.publishing_defaults) }
+
+    it 'enqueues a job of its own type with given argument' do
+      QueueingRabbit.should_receive(:enqueue).
+                     with(subject, payload, result_options)
+      subject.enqueue(payload, options)
+    end
+  end
+
+  context 'instance methods' do
+    let(:payload) { mock }
+    let(:headers) { mock }
+    let(:metadata) { stub(:headers => headers) }
+
+    subject { job_class.new(payload, metadata) }
+
+    its(:payload) { should == payload }
+    its(:metadata) { should == metadata }
+    its(:headers) { should == headers }
+
+    it { should respond_to(:perform) }
+  end
+end
+
+describe QueueingRabbit::JSONJob do
+  let(:json_job) { QueueingRabbit::JSONJob }
+  let(:payload) { JSON.dump(:foo => 'bar') }
+  let(:metadata) { mock }
+
+  subject { json_job.new(payload, metadata) }
+
+  its(:payload) { should include(:foo => 'bar') }
+
+  describe '.enqueue' do
+    let(:options) { {:persistent => true} }
+    let(:result_options) { options.merge(:routing_key => 'JSONJob') }
+
+    it 'dumps payload to JSON' do
+      QueueingRabbit.should_receive(:enqueue).
+                     with(json_job, payload, result_options)
+      json_job.enqueue({:foo => 'bar'}, options)
+    end
+  end
+end
+

data/spec/unit/queueing_rabbit/jobs/abstract_job_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe QueueingRabbit::AbstractJob do
+  let(:job_class) {
+    Class.new(QueueingRabbit::AbstractJob) do
+      queue 'test_queue', :durable => true
+      exchange 'test_exchange', :durable => false
+      bind :routing_key => 'test.*'
+    end
+  }
+
+  subject { job_class }
+
+  it { should respond_to(:exchange).with(1).argument }
+  it { should respond_to(:exchange).with(2).arguments }
+  it { should respond_to(:exchange_name) }
+  it { should respond_to(:exchange_options) }
+  it { should respond_to(:queue).with(1).argument }
+  it { should respond_to(:queue).with(2).arguments }
+  it { should respond_to(:queue_name) }
+  it { should respond_to(:queue_options) }
+  it { should respond_to(:channel_options) }
+  it { should respond_to(:channel).with(1).argument }
+  it { should respond_to(:enqueue).with(1).argument }
+  it { should respond_to(:enqueue).with(2).arguments }
+  it { should respond_to(:listening_options) }
+  it { should respond_to(:listen) }
+  it { should respond_to(:listen).with(1).argument }
+  it { should respond_to(:publishing_defaults) }
+  it { should respond_to(:publishing_defaults).with(1).argument }
+
+  its(:queue_name) { should == 'test_queue' }
+  its(:queue_options) { should include(:durable => true) }
+  its(:exchange_options) { should include(:durable => false) }
+  its(:binding_options) { should include(:routing_key => 'test.*') }
+  its(:publishing_defaults) { should include(:routing_key => 'test_queue') }
+
+  describe ".queue_size" do
+    let(:size) { mock }
+
+    before do
+      QueueingRabbit.should_receive(:queue_size).with(subject).and_return(size)
+    end
+
+    its(:queue_size) { should == size }
+  end
+
+  describe '.enqueue' do
+    let(:payload) { mock }
+    let(:options) { {:persistent => true} }
+    let(:result_options) { options.merge(job_class.publishing_defaults) }
+
+    it 'enqueues a job of its own type with given argument' do
+      QueueingRabbit.should_receive(:enqueue).
+                     with(subject, payload, result_options)
+      subject.enqueue(payload, options)
+    end
+  end
+
+  context 'instance methods' do
+    let(:payload) { mock }
+    let(:headers) { mock }
+    let(:metadata) { stub(:headers => headers) }
+
+    subject { job_class.new(payload, metadata) }
+
+    its(:payload) { should == payload }
+    its(:metadata) { should == metadata }
+    its(:headers) { should == headers }
+
+    it { should respond_to(:perform) }
+  end
+end

data/spec/unit/queueing_rabbit/jobs/json_job_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe QueueingRabbit::JSONJob do
+  let(:json_job) { QueueingRabbit::JSONJob }
+  let(:payload) { JSON.dump(:foo => 'bar') }
+  let(:metadata) { mock }
+
+  subject { json_job.new(payload, metadata) }
+
+  its(:payload) { should include(:foo => 'bar') }
+
+  describe '.enqueue' do
+    let(:options) { {:persistent => true} }
+    let(:result_options) { options.merge(:routing_key => 'JSONJob') }
+
+    it 'dumps payload to JSON' do
+      QueueingRabbit.should_receive(:enqueue).
+                     with(json_job, payload, result_options)
+      json_job.enqueue({:foo => 'bar'}, options)
+    end
+  end
+end

data/spec/unit/queueing_rabbit/worker_spec.rb

@@ -4,17 +4,23 @@ describe QueueingRabbit::Worker do
   include_context "StringIO logger"
 
   subject { QueueingRabbit::Worker }
-  let!(:job) {
-    class QueueingRabbitTestJob < QueueingRabbit::AbstractJob
-      def self.perform(arguments = {}); end
+  let(:class_based_job) {
+    Class.new(QueueingRabbit::AbstractJob) do
+      def self.perform(payload, metadata); end
     end
   }
+  let(:instance_based_job) { Class.new(QueueingRabbit::AbstractJob) }
   let(:creation) {
-    Proc.new { QueueingRabbit::Worker.new('QueueingRabbitTestJob') }
-  }
-  let(:worker) {
-    creation.call
+    Proc.new do
+      QueueingRabbit::Worker.new('QueueingRabbitClassJob', QueueingRabbitInstanceJob)
+    end
   }
+  let(:worker) { creation.call }
+
+  before do
+    stub_const("QueueingRabbitClassJob", class_based_job)
+    stub_const("QueueingRabbitInstanceJob", instance_based_job)
+  end
 
   after(:each) do
     QueueingRabbit.client = QueueingRabbit::Client::Bunny
@@ -60,38 +66,42 @@ describe QueueingRabbit::Worker do
 
   context 'instance methods' do
     let(:connection) { mock }
-    let(:channel) { mock }
-    let(:arguments) { mock }
+    let(:queue) { mock }
+    let(:payload) { mock }
+    let(:metadata) { mock }
 
     subject { worker }
 
     describe '#work' do
       before do
         QueueingRabbit.should_receive(:connection).and_return(connection)
-        connection.should_receive(:open_channel).and_yield(channel, nil)
-        connection.should_receive(:listen_queue).and_yield(arguments)
+        [class_based_job, instance_based_job].each do |job|
+          QueueingRabbit.should_receive(:follow_job_requirements).
+                         with(job).
+                         and_yield(nil, nil, queue)
+          connection.should_receive(:listen_queue).
+                     with(queue, job.listening_options).
+                     and_yield(payload, metadata)
+        end
+
+        class_based_job.should_receive(:perform).with(payload, metadata)
+        instance_based_job.should_receive(:new).
+                           with(payload, metadata).
+                           and_return(mock(:perform => nil))
       end
 
       it 'listens to queues specified by jobs' do
         subject.work
       end
 
-      context "logging" do
-        before do
-          subject.should_receive(:info)
-        end
-
-        it 'writes to the log' do
-          subject.work
-        end
+      it 'writes to the log' do
+        subject.should_receive(:info).twice
+        subject.work
       end
 
       describe '#work!' do
-        before do
-          EM.should_receive(:run).and_yield
-        end
-
         it 'runs #work and joins the eventmachine thread' do
+          EM.should_receive(:run).and_yield
           subject.work!
         end
       end

data/spec/unit/queueing_rabbit_spec.rb

@@ -5,17 +5,21 @@ describe QueueingRabbit do
 
   let(:connection) { mock }
   let(:queue_name) { mock }
-  let(:queue_options) { { :durable => true} }
+  let(:queue_options) { {:durable => true} }
   let(:channel) { mock }
-  let(:channel_options) { { :prefetch => 1, :auto_recovery => true } }
-  let(:job) do
-    qname, qopts, copts = queue_name, queue_options, channel_options
-    Class.new do
-      extend QueueingRabbit::Job
-      queue qname, qopts
-      channel copts
-    end
-  end
+  let(:channel_options) { {:prefetch => 1, :auto_recovery => true} }
+  let(:exchange_name) { mock }
+  let(:exchange_options) { {:type => :direct, :durable => true} }
+  let(:binding_options) { {:key => 'routing_key'} }
+  let(:job) {
+    stub(:queue_name => queue_name,
+         :queue_options => queue_options,
+         :channel_options => channel_options,
+         :exchange_name => exchange_name,
+         :exchange_options => exchange_options,
+         :binding_options => binding_options,
+         :bind_queue? => true)
+  }
 
   before(:each) { subject.drop_connection }
 
@@ -33,34 +37,60 @@ describe QueueingRabbit do
 
     its(:connect) { should == connection }
     its(:connection) { should == connection }
+    its(:conn) { should == connection }
   end
 
   describe ".enqueue" do
-    let(:arguments) { mock }
+    let(:payload) { mock(:to_s => 'payload') }
+    let(:options) { mock }
+    let(:exchange) { mock }
+    let(:channel) { mock }
 
     before do
       subject.instance_variable_set(:@connection, connection)
-      connection.should_receive(:open_channel).with(channel_options).
-                 and_yield(channel, nil)
-      connection.should_receive(:define_queue).with(channel,
-                                                    queue_name,
-                                                    queue_options)
-      connection.should_receive(:enqueue).with(channel,
-                                               queue_name, arguments)
+      subject.should_receive(:follow_job_requirements).
+              with(job).
+              and_yield(channel, exchange, nil)
+      connection.should_receive(:enqueue).with(exchange, payload, options)
       channel.should_receive(:close)
     end
 
     it 'returns true when a message was enqueued successfully' do
-      subject.enqueue(job, arguments).should be_true
+      subject.enqueue(job, payload, options).should be_true
     end
 
-    context 'logging' do
-      before do
-        subject.should_receive(:info).and_return(nil)
-      end
+    it 'keeps the record of enqueued job at info level' do
+      subject.should_receive(:info).and_return(nil)
+      subject.enqueue(job, payload, options).should be_true
+    end
+  end
 
-      it 'keeps the record of enqueued job at info level' do
-        subject.enqueue(job, arguments).should be_true
+  describe '.follow_job_requirements' do
+    let(:channel) { mock }
+    let(:exchange) { mock }
+    let(:queue) { mock }
+
+    before do
+      subject.instance_variable_set(:@connection, connection)
+    end
+
+    it 'opens a channel, defines an exchange and a queue, binds the queue to ' \
+       'the exchange, yields' do
+      connection.should_receive(:open_channel).with(job.channel_options).
+                                        and_yield(channel, nil)
+      connection.should_receive(:define_exchange).
+                 with(channel, job.exchange_name, job.exchange_options).
+                 and_yield(exchange)
+      connection.should_receive(:define_queue).
+                 with(channel, job.queue_name, job.queue_options).
+                 and_yield(queue)
+      connection.should_receive(:bind_queue).
+                 with(queue, exchange, job.binding_options)
+
+      subject.follow_job_requirements(job) do |ch, ex, q|
+        ch.should == channel
+        ex.should == exchange
+        q.should == q
       end
     end
   end