micro_q 0.7.0 → 0.8.0

data/spec/lib/dsl_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe MicroQ::DSL do
   describe '.worker' do
     class OtherWorker
-      worker :update
+      worker :update, :option => 'value'
     end
 
     it 'should add the method' do
@@ -11,7 +11,7 @@ describe MicroQ::DSL do
     end
 
     it 'should include the dsl module' do
-      Object.should be_is_a(MicroQ::DSL)
+      Object.should be_is_a(MicroQ::DSL::ClassMethods)
     end
 
     it 'should add the async_perform method' do
@@ -42,6 +42,12 @@ describe MicroQ::DSL do
         method.call
       end
 
+      it 'should have the \'worker\' options' do
+        MicroQ::Proxy::Instance.should_receive(:new).with(hash_including(:option => 'value')).and_return(@proxy)
+
+        method.call
+      end
+
       it 'should call the perform method' do
         @proxy.should_receive(:perform)
 
@@ -69,6 +75,12 @@ describe MicroQ::DSL do
         method.call
       end
 
+      it 'should have the \'worker\' options' do
+        MicroQ::Proxy::Instance.should_receive(:new).with(hash_including(:option => 'value')).and_return(@proxy)
+
+        method.call
+      end
+
       it 'should call the update method' do
         @proxy.should_receive(:update)
 

data/spec/lib/manager/default_spec.rb

@@ -3,25 +3,38 @@ require 'spec_helper'
 describe MicroQ::Manager::Default do
   let(:create) { -> { subject } }
 
+  before do
+    MicroQ.config.workers = 2
+  end
+
   describe '.new' do
     before do
       MicroQ.config.workers = 4
     end
 
     it 'should create a default queue' do
-      MicroQ::Queue::Default.should_receive(:new)
+      MicroQ::Queue::Default.should_receive(:new_link)
+
+      create.call
+    end
+
+    it 'should create a worker links' do
+      MicroQ::Worker::Standard.should_receive(:new_link).at_least(1)
 
       create.call
     end
 
-    it 'should create a worker pool' do
-      MicroQ::Worker::Standard.should_receive(:pool)
+    it 'should create config.workers number of links' do
+      MicroQ::Worker::Standard.should_receive(:new_link).exactly(4)
 
       create.call
     end
 
-    it 'should be a config.workers size pool' do
-      MicroQ::Worker::Standard.should_receive(:pool).with(hash_including(:size => 4))
+    it 'should pass itself to the worker' do
+      MicroQ::Worker::Standard.should_receive(:new_link).at_least(1) do |manager|
+        manager.class.should == MicroQ::Manager::Default
+        manager.wrapped_object.class.should == MicroQ::Manager::Default
+      end
 
       create.call
     end
@@ -35,41 +48,102 @@ describe MicroQ::Manager::Default do
 
   describe '#workers' do
     it 'should be the workers' do
-      subject.workers.class.should == Celluloid::PoolManager
-      subject.workers.inspect.should match(/MicroQ::Worker::Standard/)
+      subject.workers.collect {|w| w.wrapped_object.class}.uniq.should == [MicroQ::Worker::Standard]
     end
   end
 
   describe '#start' do
     it 'should not be performing' do
-      subject.workers.should_not_receive(:perform!)
+      subject.workers.each{|w| w.should_not_receive(:perform!) }
 
       subject.start
     end
 
     describe 'when the queue has dequeue-able items' do
       before do
-        @item, @other_item = mock(Hash), mock(Hash)
+        @item, @other_item = mock('Hash 1'), mock('Hash 2')
         @queue = mock(MicroQ::Queue::Default, :dequeue => [@item, @other_item])
-        MicroQ::Queue::Default.stub(:new).and_return(@queue)
+        MicroQ::Queue::Default.stub(:new_link).and_return(@queue)
 
-        @pool = mock(Celluloid::PoolManager, :idle_size => 1234, :perform! => nil)
-        MicroQ::Worker::Standard.stub(:pool).and_return(@pool)
+        @worker1 = mock(MicroQ::Worker::Standard, :perform! => nil)
+        @worker2 = mock(MicroQ::Worker::Standard, :perform! => nil)
+        MicroQ::Worker::Standard.stub(:new_link).and_return(@worker1, @worker2)
       end
 
       it 'should dequeue the number of free workers' do
-        @queue.should_receive(:dequeue).with(1234)
+        @queue.should_receive(:dequeue).with(2)
 
         subject.start
       end
 
       it 'should perform the items' do
-        @pool.should_receive(:perform!).with(@item) do
-          @pool.should_receive(:perform!).with(@other_item)
-        end
+        @worker1.should_receive(:perform!).with(@other_item)
+        @worker2.should_receive(:perform!).with(@item)
 
         subject.start
       end
     end
   end
+
+  describe '#reinitialize' do
+    let(:death) { -> { subject.reinitialize } }
+
+    before do
+      @queue = mock(MicroQ::Queue::Default, :alive? => true, :dequeue => [])
+      MicroQ::Queue::Default.stub(:new_link).and_return(@queue)
+
+      @worker1 = mock(MicroQ::Worker::Standard, :alive? => true, :perform! => nil)
+      @worker2 = mock(MicroQ::Worker::Standard, :alive? => true, :perform! => nil)
+      MicroQ::Worker::Standard.stub(:new_link).and_return(@worker1, @worker2)
+
+      subject.start
+    end
+
+    it 'should have the items' do
+      subject.queue.should == @queue
+      subject.workers.should == [@worker1, @worker2]
+    end
+
+    describe 'when the queue died' do
+      before do
+        @queue.stub(:alive?).and_return(false)
+
+        @new_queue = mock(MicroQ::Queue::Default)
+        MicroQ::Queue::Default.stub(:new_link).and_return(@new_queue)
+      end
+
+      it 'should restart the queue' do
+        MicroQ::Queue::Default.should_receive(:new_link).and_return(@new_queue)
+
+        death.call
+      end
+
+      it 'should have the new queue' do
+        death.call
+
+        subject.queue.should == @new_queue
+      end
+    end
+
+    describe 'when a worker has died' do
+      before do
+        @worker2.stub(:alive?).and_return(false)
+
+        @new_worker2 = mock(MicroQ::Worker::Standard)
+        MicroQ::Worker::Standard.stub(:new_link).and_return(@new_worker2)
+      end
+
+      it 'should restart the dead worker' do
+        MicroQ::Worker::Standard.should_receive(:new_link).and_return(@new_worker2)
+
+        death.call
+      end
+
+      it 'should have the new worker' do
+        death.call
+
+        subject.workers.should == [@worker1, @new_worker2]
+      end
+    end
+  end
 end

data/spec/lib/methods/action_mailer_spec.rb

@@ -26,10 +26,10 @@ describe MicroQ::Methods::ActionMailer do
     end
 
     describe 'when given when to run the job' do
-      let(:method) { -> { MyMailer.async(:at => "sometime") } }
+      let(:method) { -> { MyMailer.async(:at => 'sometime') } }
 
       it 'should pass the option' do
-        MicroQ::Proxy::ActionMailer.should_receive(:new).with(hash_including(:at => "sometime"))
+        MicroQ::Proxy::ActionMailer.should_receive(:new).with(hash_including(:at => 'sometime'))
 
         method.call
       end

data/spec/lib/methods/active_record_spec.rb

@@ -59,10 +59,10 @@ describe MicroQ::Methods::ActiveRecord, :active_record => true do
     it_behaves_like 'an async AR instance'
 
     describe 'when given when to run the job' do
-      let(:method) { -> { subject.async(:at => "sometime") } }
+      let(:method) { -> { subject.async(:at => 'sometime') } }
 
       it 'should pass the option' do
-        MicroQ::Proxy::Instance.should_receive(:new).with(hash_including(:at => "sometime"))
+        MicroQ::Proxy::Instance.should_receive(:new).with(hash_including(:at => 'sometime'))
 
         method.call
       end

data/spec/lib/methods/class_spec.rb

@@ -53,10 +53,10 @@ describe MicroQ::Methods::Class do
     it_behaves_like 'an async class'
 
     describe 'when given when to run the job' do
-      let(:method) { -> { subject.async(:at => "sometime") } }
+      let(:method) { -> { subject.async(:at => 'sometime') } }
 
       it 'should pass the option' do
-        MicroQ::Proxy::Class.should_receive(:new).with(hash_including(:at => "sometime"))
+        MicroQ::Proxy::Class.should_receive(:new).with(hash_including(:at => 'sometime'))
 
         method.call
       end

data/spec/lib/methods/instance_spec.rb

@@ -47,10 +47,10 @@ describe MicroQ::Methods::Instance do
     it_behaves_like 'an async instance'
 
     describe 'when given when to run the job' do
-      let(:method) { -> { subject.async(:at => "sometime") } }
+      let(:method) { -> { subject.async(:at => 'sometime') } }
 
       it 'should pass the option' do
-        MicroQ::Proxy::Instance.should_receive(:new).with(hash_including(:at => "sometime"))
+        MicroQ::Proxy::Instance.should_receive(:new).with(hash_including(:at => 'sometime'))
 
         method.call
       end

data/spec/lib/micro_q_spec.rb

@@ -6,7 +6,7 @@ describe MicroQ do
       MicroQ.configure {|config| config.class.should == MicroQ::Config }
     end
 
-    it "should cache the value" do
+    it 'should cache the value' do
       configs = []
 
       2.times { MicroQ.configure {|c| configs << c } }
@@ -27,6 +27,17 @@ describe MicroQ do
     end
   end
 
+  describe '.stats' do
+    it 'should have the statistics' do
+      klass = nil
+      MicroQ.stats do |stats|
+        klass = stats.class
+      end
+
+      klass.should == MicroQ::Statistics::Default
+    end
+  end
+
   describe '.start' do
     def start
       MicroQ.start
@@ -64,7 +75,7 @@ describe MicroQ do
     end
 
     before do
-      @manager = mock(MicroQ::Manager::Default, :start! => nil, :queue => mock("Queue"))
+      @manager = mock(MicroQ::Manager::Default, :start! => nil, :queue => mock('Queue'))
       MicroQ::Manager::Default.stub(:new).and_return(@manager)
 
       MicroQ.start

data/spec/lib/middleware/chain_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe MicroQ::Middleware::Chain do
+  class MyMiddleware; end
+
   describe MicroQ::Middleware::Chain::Base do
     subject { MicroQ::Middleware::Chain::Base.new }
 
-    class MyMiddleware; end
     class OtherMiddleware; end
 
     describe '#add' do
@@ -205,14 +206,17 @@ describe MicroQ::Middleware::Chain do
     end
 
     describe 'defaults' do
-      [MicroQ::Middleware::Server::Retry, MicroQ::Middleware::Server::Connection].each do |klass|
+      [MicroQ::Middleware::Server::Statistics,
+       MicroQ::Middleware::Server::Timeout,
+       MicroQ::Middleware::Server::Retry,
+       MicroQ::Middleware::Server::Connection].each do |klass|
         it "should include #{klass}" do
           subject.server.entries.should include(klass)
         end
       end
 
-      it 'should be 2 items long' do
-        subject.server.entries.should have(2).items
+      it 'should be 4 items long' do
+        subject.server.entries.should have(4).items
       end
     end
   end
@@ -226,8 +230,16 @@ describe MicroQ::Middleware::Chain do
       subject.client.object_id.should == subject.client.object_id
     end
 
-    it "should be empty" do
-      subject.client.entries.should == []
+    describe 'defaults' do
+      [MicroQ::Middleware::Client::Statistics].each do |klass|
+        it "should include #{klass}" do
+          subject.client.entries.should include(klass)
+        end
+      end
+
+      it 'should be 1 item long' do
+        subject.client.entries.should have(1).item
+      end
     end
   end
 
@@ -243,6 +255,12 @@ describe MicroQ::Middleware::Chain do
         subject.server.call(worker, payload) { }
       end
 
+      it 'should make a new timeout instance' do
+        MicroQ::Middleware::Server::Timeout.should_receive(:new).and_call_original
+
+        call
+      end
+
       it 'should make a new retry instance' do
         MicroQ::Middleware::Server::Retry.should_receive(:new).and_call_original
 
@@ -255,6 +273,27 @@ describe MicroQ::Middleware::Chain do
         call
       end
 
+      it 'should make a new statistics instance' do
+        MicroQ::Middleware::Server::Statistics.should_receive(:new).and_call_original
+
+        call
+      end
+
+      it 'should not remove the Statistics' do
+        subject.server.remove(MicroQ::Middleware::Server::Statistics)
+
+        subject.server.entries.should include(MicroQ::Middleware::Server::Statistics)
+      end
+
+      it 'should call the timeout middleware' do
+        @timeout = mock(MicroQ::Middleware::Server::Timeout)
+        MicroQ::Middleware::Server::Timeout.stub(:new).and_return(@timeout)
+
+        @timeout.should_receive(:call).with(worker, payload)
+
+        call
+      end
+
       it 'should call the retry middleware' do
         @retry = mock(MicroQ::Middleware::Server::Retry)
         MicroQ::Middleware::Server::Retry.stub(:new).and_return(@retry)
@@ -272,6 +311,44 @@ describe MicroQ::Middleware::Chain do
 
         call
       end
+
+      it 'should call the statistics middleware' do
+        statistics = mock(MicroQ::Middleware::Server::Connection)
+        MicroQ::Middleware::Server::Connection.stub(:new).and_return(statistics)
+
+        statistics.should_receive(:call).with(worker, payload)
+
+        call
+      end
+    end
+
+    describe 'client' do
+      let(:opts) { mock('options') }
+
+      def call
+        subject.client.call(payload, opts) { }
+      end
+
+      it 'should make a new statistics instance' do
+        MicroQ::Middleware::Client::Statistics.should_receive(:new).and_call_original
+
+        call
+      end
+
+      it 'should not remove the Statistics' do
+        subject.client.remove(MicroQ::Middleware::Client::Statistics)
+
+        subject.client.entries.should include(MicroQ::Middleware::Client::Statistics)
+      end
+
+      it 'should call the statistics middleware' do
+        statistics = mock(MicroQ::Middleware::Client::Statistics)
+        MicroQ::Middleware::Client::Statistics.stub(:new).and_return(statistics)
+
+        statistics.should_receive(:call).with(payload, opts)
+
+        call
+      end
     end
   end
 end

data/spec/lib/middleware/client/statistics_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe MicroQ::Middleware::Client::Statistics, :middleware => true do
+  describe '#call' do
+    let(:foo) { mock('Foo', :bar => nil) }
+    let(:block) { -> { foo.bar } }
+
+    def call
+      subject.call @payload, {}, &block
+    end
+
+    before do
+      @stats = mock(MicroQ::Statistics::Default, :incr => nil)
+      MicroQ::Statistics::Default.stub(:stats).and_yield(@stats)
+    end
+
+    it 'should execute the block' do
+      foo.should_receive(:bar)
+
+      call
+    end
+
+    it 'should call into the statistics backend' do
+      MicroQ::Statistics::Default.should_receive(:stats)
+
+      call
+    end
+
+    it 'should log a enqueued message' do
+      @stats.should_receive(:incr) do |*args|
+        args.should include('messages:enqueued')
+      end
+
+      call
+    end
+
+    it 'should log the enqueued class message' do
+      @stats.should_receive(:incr) do |*args|
+        args.should include("messages:#{@payload['class']}:enqueued")
+      end
+
+      call
+    end
+
+    it 'should log the queue' do
+      @stats.should_receive(:incr) do |*args|
+        args.should include('queues:a-queue:enqueued')
+      end
+
+      call
+    end
+  end
+end

data/spec/lib/middleware/server/connection_spec.rb

@@ -3,7 +3,7 @@ require 'active_record'
 
 describe MicroQ::Middleware::Server::Connection, :middleware => true do
   describe '#call' do
-    let(:foo) { mock("Foo", :bar => nil) }
+    let(:foo) { mock('Foo', :bar => nil) }
     let(:block) { -> { foo.bar } }
 
     def call

data/spec/lib/middleware/server/retry_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe MicroQ::Middleware::Server::Retry, :middleware => true do
   describe '#call' do
-    let(:foo) { mock("Foo", :bar => nil) }
+    let(:foo) { mock('Foo', :bar => nil) }
     let(:block) { -> { foo.bar } }
 
     def call
@@ -16,9 +16,14 @@ describe MicroQ::Middleware::Server::Retry, :middleware => true do
     end
 
     describe 'when the block raises an Exception' do
-      let(:exception) { Exception.new }
+      let(:exception) { Exception.new('an exception') }
       let(:block) { -> { raise exception } }
 
+      before do
+        @stats = mock(MicroQ::Statistics::Default, :incr => nil)
+        MicroQ::Statistics::Default.stub(:stats).and_yield(@stats)
+      end
+
       describe 'when retry is disabled' do
         before do
           @payload['retry'] = false
@@ -27,7 +32,7 @@ describe MicroQ::Middleware::Server::Retry, :middleware => true do
         it 'should re-raise the error' do
           expect {
             call
-          }.to raise_error(exception)
+          }.to raise_error(Exception, 'an exception')
         end
       end
 
@@ -39,7 +44,31 @@ describe MicroQ::Middleware::Server::Retry, :middleware => true do
         it 'should re-raise the error' do
           expect {
             call
-          }.to raise_error(exception)
+          }.to raise_error(Exception, 'an exception')
+        end
+
+        it 'should log the retry' do
+          @stats.should_receive(:incr) do |*args|
+            args.should include('messages:retry')
+          end
+
+          safe(:call)
+        end
+
+        it 'should log the class\' retry' do
+          @stats.should_receive(:incr) do |*args|
+            args.should include("messages:#{@payload['class']}:retry")
+          end
+
+          safe(:call)
+        end
+
+        it 'should log the queues\' retry' do
+          @stats.should_receive(:incr) do |*args|
+            args.should include('queues:a-queue:retry')
+          end
+
+          safe(:call)
         end
 
         it 'should increment the number of retries' do

data/spec/lib/middleware/server/statistics_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe MicroQ::Middleware::Server::Statistics, :middleware => true do
+  describe '#call' do
+    let(:foo) { mock('Foo', :bar => nil) }
+    let(:block) { -> { foo.bar } }
+
+    def call
+      subject.call @worker, @payload, &block
+    end
+
+    before do
+      @stats = mock(MicroQ::Statistics::Default, :incr => nil)
+      MicroQ::Statistics::Default.stub(:stats).and_yield(@stats)
+    end
+
+    it 'should execute the block' do
+      foo.should_receive(:bar)
+
+      call
+    end
+
+    it 'should call into the statistics backend' do
+      MicroQ::Statistics::Default.should_receive(:stats)
+
+      call
+    end
+
+    it 'should log a completed message' do
+      @stats.should_receive(:incr) do |*args|
+        args.should include('messages:performed')
+      end
+
+      call
+    end
+
+    it 'should log the completed class message' do
+      @stats.should_receive(:incr) do |*args|
+        args.should include("messages:#{@payload['class']}:performed")
+      end
+
+      call
+    end
+
+    it 'should log the queue' do
+      @stats.should_receive(:incr) do |*args|
+        args.should include('queues:a-queue:performed')
+      end
+
+      call
+    end
+  end
+end

data/spec/lib/middleware/server/timeout_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe MicroQ::Middleware::Server::Timeout, :middleware => true do
+  describe '#call' do
+    let(:foo) { mock('Foo', :bar => nil) }
+    let(:block) { -> { foo.bar } }
+
+    def call
+      subject.call @worker, @payload, &block
+    end
+
+    before do
+      Timecop.freeze(DateTime.now)
+    end
+
+    it 'should execute the block' do
+      foo.should_receive(:bar)
+
+      call
+    end
+
+    it 'should timeout after 10 minutes' do
+      subject.should_receive(:timeout).with(10 * 60)
+
+      call
+    end
+
+    describe 'when the timeout is set' do
+      before do
+        @payload.merge!('timeout' => 60)
+      end
+
+      it 'should timeout after 60 seconds' do
+        subject.should_receive(:timeout).with(60)
+
+        call
+      end
+    end
+  end
+end

data/spec/lib/proxies/base_spec.rb

@@ -61,14 +61,14 @@ describe MicroQ::Proxy::Base do
           it "should have an error for #{type.inspect}" do
             options[:class] = type
 
-            subject.errors.should include("Proxies require a valid class")
+            subject.errors.should include('Proxies require a valid class')
           end
         end
       end
     end
   end
 
-  describe "#respond_to?" do
+  describe '#respond_to?' do
     it 'should be false' do
       subject.respond_to?(:not_a_method).should == false
     end

data/spec/lib/proxies/instance_spec.rb

@@ -14,7 +14,7 @@ describe MicroQ::Proxy::Instance do
     subject.class.ancestors.should include(MicroQ::Proxy::Base)
   end
 
-  describe "#respond_to?" do
+  describe '#respond_to?' do
     it 'should be false' do
       subject.respond_to?(:not_a_method).should == false
     end